grant/intellijai
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parser: raise corpus parse rate from 57% to 69%

Browse Source 
Grammar gains: array types, directive flags, declaration-level directive
modifiers, parameter markers, backticked declaration names, notes after a
block-valued declaration, 'if cond then stmt', 'ifx c else v', '#module_parameters'
two-group form, '(.*)' prefix dereference, and '#asm' bodies consumed opaquely
(they are x86-64 assembly, not Jai).

Return items no longer take a default value: allowing one made
'f: (K) -> u32 = null' swallow the enclosing parameter's default and read the
rest of the parameter list as extra return values.
This commit is contained in:
hgranthorner
2026-08-04 12:13:26 -04:00
parent 37809b8aa7
commit 840a503e40
19 changed files with 727 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

553
src/main/gen/dev/hgh/jai/parser/JaiParser.java
View File

@@ -39,14 +39,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
create_token_set_(ADD_EXPR, AND_EXPR, ARRAY_LITERAL_EXPR, ARRAY_TYPE_EXPR,
ASSIGN_EXPR, AUTO_CAST_EXPR, BACKTICK_EXPR, BIT_AND_EXPR,
BIT_OR_EXPR, BIT_XOR_EXPR, BUILTIN_CALL_EXPR, CALL_EXPR,
CAST_EXPR, DEREF_EXPR, DIRECTIVE_EXPR, ENUM_EXPR,
EQUALITY_EXPR, EXPR, IFX_EXPR, INDEX_EXPR,
INLINE_EXPR, INTERFACE_EXPR, LAMBDA_EXPR, LITERAL_EXPR,
MEMBER_EXPR, MUL_EXPR, OR_EXPR, PAREN_EXPR,
PREFIX_EXPR, PRIMARY_EXPR, PROC_LITERAL_EXPR, RANGE_EXPR,
REF_EXPR, RELATIONAL_EXPR, SHIFT_EXPR, STRUCT_EXPR,
STRUCT_LITERAL_EXPR, TYPED_ARRAY_LITERAL_EXPR, TYPED_STRUCT_LITERAL_EXPR, UNARY_DOT_EXPR,
UNINITIALIZED_EXPR, UNION_EXPR),
CAST_EXPR, DEREF_CAST_EXPR, DEREF_EXPR, DIRECTIVE_EXPR,
ENUM_EXPR, EQUALITY_EXPR, EXPR, IFX_EXPR,
INDEX_EXPR, INLINE_EXPR, INTERFACE_EXPR, LAMBDA_EXPR,
LITERAL_EXPR, MEMBER_EXPR, MUL_EXPR, OR_EXPR,
PAREN_EXPR, PREFIX_EXPR, PRIMARY_EXPR, PROC_LITERAL_EXPR,
RANGE_EXPR, REF_EXPR, RELATIONAL_EXPR, SHIFT_EXPR,
STRUCT_EXPR, STRUCT_LITERAL_EXPR, TYPED_ARRAY_LITERAL_EXPR, TYPED_STRUCT_LITERAL_EXPR,
UNARY_DOT_EXPR, UNINITIALIZED_EXPR, UNION_EXPR),
};
/* ********************************************************** */
@@ -326,31 +326,49 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// <<dirPlain>> | 'using'
// procModifier | 'using'
static boolean declModifier_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declModifier_")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirPlain(builder_, level_ + 1);
result_ = procModifier(builder_, level_ + 1);
if (!result_) result_ = consumeToken(builder_, KW_USING);
exit_section_(builder_, marker_, null, result_);
return result_;
}
/* ********************************************************** */
// IDENT (',' IDENT)*
public static boolean declNames(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declNames")) return false;
if (!nextTokenIs(builder_, IDENT)) return false;
// ['`'] IDENT
public static boolean declName(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declName")) return false;
if (!nextTokenIs(builder_, "<decl name>", BACKTICK, IDENT)) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, IDENT);
result_ = result_ && declNames_1(builder_, level_ + 1);
exit_section_(builder_, marker_, DECL_NAMES, result_);
Marker marker_ = enter_section_(builder_, level_, _NONE_, DECL_NAME, "<decl name>");
result_ = declName_0(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, IDENT);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
// (',' IDENT)*
// ['`']
private static boolean declName_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declName_0")) return false;
consumeToken(builder_, BACKTICK);
return true;
}
/* ********************************************************** */
// declName (',' declName)*
public static boolean declNames(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declNames")) return false;
if (!nextTokenIs(builder_, "<decl names>", BACKTICK, IDENT)) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, DECL_NAMES, "<decl names>");
result_ = declName(builder_, level_ + 1);
result_ = result_ && declNames_1(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
// (',' declName)*
private static boolean declNames_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declNames_1")) return false;
while (true) {
@@ -361,18 +379,19 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
// ',' IDENT
// ',' declName
private static boolean declNames_1_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declNames_1_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeTokens(builder_, 0, COMMA, IDENT);
result_ = consumeToken(builder_, COMMA);
result_ = result_ && declName(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
/* ********************************************************** */
// ':' [<<exprNoAssign>>] [('=' | ':') initializer]
// ':' [<<exprNoAssign>>] procModifier* [('=' | ':') initializer]
// | ':=' initializer
// | '::' initializer
static boolean declTail_(PsiBuilder builder_, int level_) {
@@ -386,7 +405,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// ':' [<<exprNoAssign>>] [('=' | ':') initializer]
// ':' [<<exprNoAssign>>] procModifier* [('=' | ':') initializer]
private static boolean declTail__0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0")) return false;
boolean result_;
@@ -394,6 +413,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
result_ = consumeToken(builder_, COLON);
result_ = result_ && declTail__0_1(builder_, level_ + 1);
result_ = result_ && declTail__0_2(builder_, level_ + 1);
result_ = result_ && declTail__0_3(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
@@ -405,27 +425,38 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
// [('=' | ':') initializer]
// procModifier*
private static boolean declTail__0_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_2")) return false;
declTail__0_2_0(builder_, level_ + 1);
while (true) {
int pos_ = current_position_(builder_);
if (!procModifier(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "declTail__0_2", pos_)) break;
}
return true;
}
// [('=' | ':') initializer]
private static boolean declTail__0_3(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_3")) return false;
declTail__0_3_0(builder_, level_ + 1);
return true;
}
// ('=' | ':') initializer
private static boolean declTail__0_2_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_2_0")) return false;
private static boolean declTail__0_3_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_3_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = declTail__0_2_0_0(builder_, level_ + 1);
result_ = declTail__0_3_0_0(builder_, level_ + 1);
result_ = result_ && initializer(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// '=' | ':'
private static boolean declTail__0_2_0_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_2_0_0")) return false;
private static boolean declTail__0_3_0_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declTail__0_3_0_0")) return false;
boolean result_;
result_ = consumeToken(builder_, EQ);
if (!result_) result_ = consumeToken(builder_, COLON);
@@ -455,7 +486,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// <<isDeclarationAhead>> declModifier_* declNames declTail_ NOTE* semi
// <<isDeclarationAhead>> declModifier_* declNames declTail_ semiWithNotes_
public static boolean declaration(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declaration")) return false;
boolean result_;
@@ -464,8 +495,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
result_ = result_ && declaration_1(builder_, level_ + 1);
result_ = result_ && declNames(builder_, level_ + 1);
result_ = result_ && declTail_(builder_, level_ + 1);
result_ = result_ && declaration_4(builder_, level_ + 1);
result_ = result_ && semi(builder_, level_ + 1);
result_ = result_ && semiWithNotes_(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
@@ -481,17 +511,6 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
// NOTE*
private static boolean declaration_4(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "declaration_4")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "declaration_4", pos_)) break;
}
return true;
}
/* ********************************************************** */
// ['`'] 'defer' statement
public static boolean deferStatement(PsiBuilder builder_, int level_) {
@@ -514,10 +533,12 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// <<dir "#assert">> expr [expr]
// | <<dirWithBlock>> [',' IDENT] block
// | <<dirWithOperand>> [',' IDENT] [expr]
// | <<dirPlain>> [',' IDENT]
// <<dir "#asm">> directiveFlag_* <<opaqueBlock>>
// | <<dir "#assert">> expr [expr]
// | <<dir "#module_parameters">> '(' [paramList] ')' ['(' [paramList] ')'] [block]
// | <<dirWithBlock>> directiveFlag_* block
// | <<dirWithOperand>> directiveFlag_* [expr]
// | <<dirPlain>> directiveFlag_*
public static boolean directiveExpr(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr")) return false;
boolean result_;
@@ -526,94 +547,198 @@ public class JaiParser implements PsiParser, LightPsiParser {
if (!result_) result_ = directiveExpr_1(builder_, level_ + 1);
if (!result_) result_ = directiveExpr_2(builder_, level_ + 1);
if (!result_) result_ = directiveExpr_3(builder_, level_ + 1);
if (!result_) result_ = directiveExpr_4(builder_, level_ + 1);
if (!result_) result_ = directiveExpr_5(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
// <<dir "#assert">> expr [expr]
// <<dir "#asm">> directiveFlag_* <<opaqueBlock>>
private static boolean directiveExpr_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dir(builder_, level_ + 1, "#asm");
result_ = result_ && directiveExpr_0_1(builder_, level_ + 1);
result_ = result_ && opaqueBlock(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// directiveFlag_*
private static boolean directiveExpr_0_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_0_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "directiveExpr_0_1", pos_)) break;
}
return true;
}
// <<dir "#assert">> expr [expr]
private static boolean directiveExpr_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_1")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dir(builder_, level_ + 1, "#assert");
result_ = result_ && expr(builder_, level_ + 1, -1);
result_ = result_ && directiveExpr_0_2(builder_, level_ + 1);
result_ = result_ && directiveExpr_1_2(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [expr]
private static boolean directiveExpr_0_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_0_2")) return false;
private static boolean directiveExpr_1_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_1_2")) return false;
expr(builder_, level_ + 1, -1);
return true;
}
// <<dirWithBlock>> [',' IDENT] block
private static boolean directiveExpr_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_1")) return false;
// <<dir "#module_parameters">> '(' [paramList] ')' ['(' [paramList] ')'] [block]
private static boolean directiveExpr_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dir(builder_, level_ + 1, "#module_parameters");
result_ = result_ && consumeToken(builder_, LPAREN);
result_ = result_ && directiveExpr_2_2(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, RPAREN);
result_ = result_ && directiveExpr_2_4(builder_, level_ + 1);
result_ = result_ && directiveExpr_2_5(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [paramList]
private static boolean directiveExpr_2_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_2")) return false;
paramList(builder_, level_ + 1);
return true;
}
// ['(' [paramList] ')']
private static boolean directiveExpr_2_4(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_4")) return false;
directiveExpr_2_4_0(builder_, level_ + 1);
return true;
}
// '(' [paramList] ')'
private static boolean directiveExpr_2_4_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_4_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, LPAREN);
result_ = result_ && directiveExpr_2_4_0_1(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, RPAREN);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [paramList]
private static boolean directiveExpr_2_4_0_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_4_0_1")) return false;
paramList(builder_, level_ + 1);
return true;
}
// [block]
private static boolean directiveExpr_2_5(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_5")) return false;
block(builder_, level_ + 1);
return true;
}
// <<dirWithBlock>> directiveFlag_* block
private static boolean directiveExpr_3(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_3")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirWithBlock(builder_, level_ + 1);
result_ = result_ && directiveExpr_1_1(builder_, level_ + 1);
result_ = result_ && directiveExpr_3_1(builder_, level_ + 1);
result_ = result_ && block(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [',' IDENT]
private static boolean directiveExpr_1_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_1_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
// directiveFlag_*
private static boolean directiveExpr_3_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_3_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "directiveExpr_3_1", pos_)) break;
}
return true;
}
// <<dirWithOperand>> [',' IDENT] [expr]
private static boolean directiveExpr_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2")) return false;
// <<dirWithOperand>> directiveFlag_* [expr]
private static boolean directiveExpr_4(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_4")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirWithOperand(builder_, level_ + 1);
result_ = result_ && directiveExpr_2_1(builder_, level_ + 1);
result_ = result_ && directiveExpr_2_2(builder_, level_ + 1);
result_ = result_ && directiveExpr_4_1(builder_, level_ + 1);
result_ = result_ && directiveExpr_4_2(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [',' IDENT]
private static boolean directiveExpr_2_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
// directiveFlag_*
private static boolean directiveExpr_4_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_4_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "directiveExpr_4_1", pos_)) break;
}
return true;
}
// [expr]
private static boolean directiveExpr_2_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_2_2")) return false;
private static boolean directiveExpr_4_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_4_2")) return false;
expr(builder_, level_ + 1, -1);
return true;
}
// <<dirPlain>> [',' IDENT]
private static boolean directiveExpr_3(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_3")) return false;
// <<dirPlain>> directiveFlag_*
private static boolean directiveExpr_5(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_5")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirPlain(builder_, level_ + 1);
result_ = result_ && directiveExpr_3_1(builder_, level_ + 1);
result_ = result_ && directiveExpr_5_1(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// [',' IDENT]
private static boolean directiveExpr_3_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_3_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
// directiveFlag_*
private static boolean directiveExpr_5_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveExpr_5_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "directiveExpr_5_1", pos_)) break;
}
return true;
}
/* ********************************************************** */
// <<dirBare>> [',' IDENT] [';']
// ',' IDENT
static boolean directiveFlag_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveFlag_")) return false;
if (!nextTokenIs(builder_, COMMA)) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeTokens(builder_, 0, COMMA, IDENT);
exit_section_(builder_, marker_, null, result_);
return result_;
}
/* ********************************************************** */
// <<dirBare>> directiveFlag_* [';']
public static boolean directiveStatement(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveStatement")) return false;
boolean result_;
@@ -625,10 +750,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// [',' IDENT]
// directiveFlag_*
private static boolean directiveStatement_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "directiveStatement_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "directiveStatement_1", pos_)) break;
}
return true;
}
@@ -716,15 +845,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// expr (',' expr)* NOTE* semi
// expr (',' expr)* semiWithNotes_
public static boolean expressionStatement(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "expressionStatement")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, EXPRESSION_STATEMENT, "<expression statement>");
result_ = expr(builder_, level_ + 1, -1);
result_ = result_ && expressionStatement_1(builder_, level_ + 1);
result_ = result_ && expressionStatement_2(builder_, level_ + 1);
result_ = result_ && semi(builder_, level_ + 1);
result_ = result_ && semiWithNotes_(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
@@ -751,17 +879,6 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// NOTE*
private static boolean expressionStatement_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "expressionStatement_2")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "expressionStatement_2", pos_)) break;
}
return true;
}
/* ********************************************************** */
// '<' | '*'
static boolean forModifier_(PsiBuilder builder_, int level_) {
@@ -1069,7 +1186,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// 'operator' operatorSymbol '::' expr NOTE* semi
// 'operator' operatorSymbol '::' expr semiWithNotes_
public static boolean operatorDeclaration(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "operatorDeclaration")) return false;
if (!nextTokenIs(builder_, KW_OPERATOR)) return false;
@@ -1079,23 +1196,11 @@ public class JaiParser implements PsiParser, LightPsiParser {
result_ = result_ && operatorSymbol(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, COLON_COLON);
result_ = result_ && expr(builder_, level_ + 1, -1);
result_ = result_ && operatorDeclaration_4(builder_, level_ + 1);
result_ = result_ && semi(builder_, level_ + 1);
result_ = result_ && semiWithNotes_(builder_, level_ + 1);
exit_section_(builder_, marker_, OPERATOR_DECLARATION, result_);
return result_;
}
// NOTE*
private static boolean operatorDeclaration_4(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "operatorDeclaration_4")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "operatorDeclaration_4", pos_)) break;
}
return true;
}
/* ********************************************************** */
// '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '>' | '<=' | '>='
// | '&' | '|' | '^' | '~' | '<<' | '>>' | '<<<' | '>>>'
@@ -1171,6 +1276,18 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
/* ********************************************************** */
// <<dirPlain>> | 'using'
static boolean paramModifier_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "paramModifier_")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirPlain(builder_, level_ + 1);
if (!result_) result_ = consumeToken(builder_, KW_USING);
exit_section_(builder_, marker_, null, result_);
return result_;
}
/* ********************************************************** */
// ['$' | '$$'] IDENT
public static boolean paramName(PsiBuilder builder_, int level_) {
@@ -1308,7 +1425,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// ['using'] parameterTail_
// paramModifier_* parameterTail_
public static boolean parameter(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "parameter")) return false;
boolean result_;
@@ -1319,10 +1436,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// ['using']
// paramModifier_*
private static boolean parameter_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "parameter_0")) return false;
consumeToken(builder_, KW_USING);
while (true) {
int pos_ = current_position_(builder_);
if (!paramModifier_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "parameter_0", pos_)) break;
}
return true;
}
@@ -1527,9 +1648,9 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// <<dirWithBlock>> block
// | <<dirWithOperand>> [',' IDENT] [expr]
// | <<dirPlain>> [',' IDENT]
// <<dirWithBlock>> directiveFlag_* block
// | <<dirWithOperand>> directiveFlag_* [expr]
// | <<dirPlain>> directiveFlag_*
public static boolean procModifier(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier")) return false;
boolean result_;
@@ -1541,18 +1662,30 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// <<dirWithBlock>> block
// <<dirWithBlock>> directiveFlag_* block
private static boolean procModifier_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = dirWithBlock(builder_, level_ + 1);
result_ = result_ && procModifier_0_1(builder_, level_ + 1);
result_ = result_ && block(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// <<dirWithOperand>> [',' IDENT] [expr]
// directiveFlag_*
private static boolean procModifier_0_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_0_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "procModifier_0_1", pos_)) break;
}
return true;
}
// <<dirWithOperand>> directiveFlag_* [expr]
private static boolean procModifier_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_1")) return false;
boolean result_;
@@ -1564,10 +1697,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// [',' IDENT]
// directiveFlag_*
private static boolean procModifier_1_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_1_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "procModifier_1_1", pos_)) break;
}
return true;
}
@@ -1578,7 +1715,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
// <<dirPlain>> [',' IDENT]
// <<dirPlain>> directiveFlag_*
private static boolean procModifier_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_2")) return false;
boolean result_;
@@ -1589,10 +1726,14 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// [',' IDENT]
// directiveFlag_*
private static boolean procModifier_2_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "procModifier_2_1")) return false;
parseTokens(builder_, 0, COMMA, IDENT);
while (true) {
int pos_ = current_position_(builder_);
if (!directiveFlag_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "procModifier_2_1", pos_)) break;
}
return true;
}
@@ -1706,14 +1847,13 @@ public class JaiParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// [<<isParamNameAhead>> IDENT ':'] <<exprNoAssign>> ['=' initializer]
// [<<isParamNameAhead>> IDENT ':'] <<exprNoAssign>>
public static boolean returnItem(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "returnItem")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, RETURN_ITEM, "<return item>");
result_ = returnItem_0(builder_, level_ + 1);
result_ = result_ && exprNoAssign(builder_, level_ + 1);
result_ = result_ && returnItem_2(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
}
@@ -1736,26 +1876,8 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// ['=' initializer]
private static boolean returnItem_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "returnItem_2")) return false;
returnItem_2_0(builder_, level_ + 1);
return true;
}
// '=' initializer
private static boolean returnItem_2_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "returnItem_2_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, EQ);
result_ = result_ && initializer(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
/* ********************************************************** */
// 'return' [expr (',' expr)*] NOTE* semi
// 'return' [expr (',' expr)*] semiWithNotes_
public static boolean returnStatement(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "returnStatement")) return false;
if (!nextTokenIs(builder_, KW_RETURN)) return false;
@@ -1763,8 +1885,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, KW_RETURN);
result_ = result_ && returnStatement_1(builder_, level_ + 1);
result_ = result_ && returnStatement_2(builder_, level_ + 1);
result_ = result_ && semi(builder_, level_ + 1);
result_ = result_ && semiWithNotes_(builder_, level_ + 1);
exit_section_(builder_, marker_, RETURN_STATEMENT, result_);
return result_;
}
@@ -1809,17 +1930,6 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// NOTE*
private static boolean returnStatement_2(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "returnStatement_2")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "returnStatement_2", pos_)) break;
}
return true;
}
/* ********************************************************** */
// <<isReturnGroupAhead>> returnGroup | returnItem (',' returnItem)*
static boolean returnTypes_(PsiBuilder builder_, int level_) {
@@ -1888,6 +1998,62 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
/* ********************************************************** */
// <<prevEndsConstruct>> NOTE* | NOTE* ';'
static boolean semiWithNotes_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "semiWithNotes_")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = semiWithNotes__0(builder_, level_ + 1);
if (!result_) result_ = semiWithNotes__1(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// <<prevEndsConstruct>> NOTE*
private static boolean semiWithNotes__0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "semiWithNotes__0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = prevEndsConstruct(builder_, level_ + 1);
result_ = result_ && semiWithNotes__0_1(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// NOTE*
private static boolean semiWithNotes__0_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "semiWithNotes__0_1")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "semiWithNotes__0_1", pos_)) break;
}
return true;
}
// NOTE* ';'
private static boolean semiWithNotes__1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "semiWithNotes__1")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = semiWithNotes__1_0(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, SEMICOLON);
exit_section_(builder_, marker_, null, result_);
return result_;
}
// NOTE*
private static boolean semiWithNotes__1_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "semiWithNotes__1_0")) return false;
while (true) {
int pos_ = current_position_(builder_);
if (!consumeToken(builder_, NOTE)) break;
if (!empty_element_parsed_guard_(builder_, "semiWithNotes__1_0", pos_)) break;
}
return true;
}
/* ********************************************************** */
// ';'
// | block
@@ -1903,8 +2069,8 @@ public class JaiParser implements PsiParser, LightPsiParser {
// | operatorDeclaration
// | usingStatement
// | noteStatement
// | directiveStatement
// | declaration
// | directiveStatement
// | expressionStatement
public static boolean statement(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "statement")) return false;
@@ -1924,8 +2090,8 @@ public class JaiParser implements PsiParser, LightPsiParser {
if (!result_) result_ = operatorDeclaration(builder_, level_ + 1);
if (!result_) result_ = usingStatement(builder_, level_ + 1);
if (!result_) result_ = noteStatement(builder_, level_ + 1);
if (!result_) result_ = directiveStatement(builder_, level_ + 1);
if (!result_) result_ = declaration(builder_, level_ + 1);
if (!result_) result_ = directiveStatement(builder_, level_ + 1);
if (!result_) result_ = expressionStatement(builder_, level_ + 1);
exit_section_(builder_, level_, marker_, result_, false, null);
return result_;
@@ -2169,24 +2335,26 @@ public class JaiParser implements PsiParser, LightPsiParser {
// 11: BINARY(addExpr)
// 12: BINARY(mulExpr)
// 13: PREFIX(prefixExpr)
// 14: ATOM(arrayTypeExpr)
// 15: ATOM(castExpr)
// 16: PREFIX(autoCastExpr)
// 17: PREFIX(inlineExpr)
// 18: ATOM(ifxExpr)
// 19: POSTFIX(callExpr)
// 20: POSTFIX(indexExpr)
// 21: POSTFIX(memberExpr)
// 22: POSTFIX(derefExpr)
// 23: POSTFIX(typedStructLiteralExpr)
// 24: POSTFIX(typedArrayLiteralExpr)
// 25: ATOM(primaryExpr)
// 14: PREFIX(derefCastExpr)
// 15: ATOM(arrayTypeExpr)
// 16: ATOM(castExpr)
// 17: PREFIX(autoCastExpr)
// 18: PREFIX(inlineExpr)
// 19: ATOM(ifxExpr)
// 20: POSTFIX(callExpr)
// 21: POSTFIX(indexExpr)
// 22: POSTFIX(memberExpr)
// 23: POSTFIX(derefExpr)
// 24: POSTFIX(typedStructLiteralExpr)
// 25: POSTFIX(typedArrayLiteralExpr)
// 26: ATOM(primaryExpr)
public static boolean expr(PsiBuilder builder_, int level_, int priority_) {
if (!recursion_guard_(builder_, level_, "expr")) return false;
addVariant(builder_, "<expr>");
boolean result_, pinned_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<expr>");
result_ = prefixExpr(builder_, level_ + 1);
if (!result_) result_ = derefCastExpr(builder_, level_ + 1);
if (!result_) result_ = arrayTypeExpr(builder_, level_ + 1);
if (!result_) result_ = castExpr(builder_, level_ + 1);
if (!result_) result_ = autoCastExpr(builder_, level_ + 1);
@@ -2256,27 +2424,27 @@ public class JaiParser implements PsiParser, LightPsiParser {
result_ = expr(builder_, level_, 12);
exit_section_(builder_, level_, marker_, MUL_EXPR, result_, true, null);
}
else if (priority_ < 19 && callExpr_0(builder_, level_ + 1)) {
else if (priority_ < 20 && callExpr_0(builder_, level_ + 1)) {
result_ = true;
exit_section_(builder_, level_, marker_, CALL_EXPR, result_, true, null);
}
else if (priority_ < 20 && indexExpr_0(builder_, level_ + 1)) {
else if (priority_ < 21 && indexExpr_0(builder_, level_ + 1)) {
result_ = true;
exit_section_(builder_, level_, marker_, INDEX_EXPR, result_, true, null);
}
else if (priority_ < 21 && memberExpr_0(builder_, level_ + 1)) {
else if (priority_ < 22 && memberExpr_0(builder_, level_ + 1)) {
result_ = true;
exit_section_(builder_, level_, marker_, MEMBER_EXPR, result_, true, null);
}
else if (priority_ < 22 && consumeTokenSmart(builder_, POSTFIX_DEREFERENCE)) {
else if (priority_ < 23 && consumeTokenSmart(builder_, POSTFIX_DEREFERENCE)) {
result_ = true;
exit_section_(builder_, level_, marker_, DEREF_EXPR, result_, true, null);
}
else if (priority_ < 23 && typedStructLiteralExpr_0(builder_, level_ + 1)) {
else if (priority_ < 24 && typedStructLiteralExpr_0(builder_, level_ + 1)) {
result_ = true;
exit_section_(builder_, level_, marker_, TYPED_STRUCT_LITERAL_EXPR, result_, true, null);
}
else if (priority_ < 24 && typedArrayLiteralExpr_0(builder_, level_ + 1)) {
else if (priority_ < 25 && typedArrayLiteralExpr_0(builder_, level_ + 1)) {
result_ = true;
exit_section_(builder_, level_, marker_, TYPED_ARRAY_LITERAL_EXPR, result_, true, null);
}
@@ -2352,6 +2520,18 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_ || pinned_;
}
public static boolean derefCastExpr(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "derefCastExpr")) return false;
if (!nextTokenIsSmart(builder_, LPAREN)) return false;
boolean result_, pinned_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
result_ = parseTokensSmart(builder_, 0, LPAREN, POSTFIX_DEREFERENCE, RPAREN);
pinned_ = result_;
result_ = pinned_ && expr(builder_, level_, 14);
exit_section_(builder_, level_, marker_, DEREF_CAST_EXPR, result_, pinned_, null);
return result_ || pinned_;
}
// '[' ['..' | expr] ']' expr
public static boolean arrayTypeExpr(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "arrayTypeExpr")) return false;
@@ -2419,7 +2599,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
result_ = autoCastExpr_0(builder_, level_ + 1);
pinned_ = result_;
result_ = pinned_ && expr(builder_, level_, 16);
result_ = pinned_ && expr(builder_, level_, 17);
exit_section_(builder_, level_, marker_, AUTO_CAST_EXPR, result_, pinned_, null);
return result_ || pinned_;
}
@@ -2449,7 +2629,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
result_ = inlineExpr_0(builder_, level_ + 1);
pinned_ = result_;
result_ = pinned_ && expr(builder_, level_, 17);
result_ = pinned_ && expr(builder_, level_, 18);
exit_section_(builder_, level_, marker_, INLINE_EXPR, result_, pinned_, null);
return result_ || pinned_;
}
@@ -2463,7 +2643,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
return result_;
}
// 'ifx' expr ['then'] expr ['else' expr]
// 'ifx' expr ['then'] [expr] ['else' expr]
public static boolean ifxExpr(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ifxExpr")) return false;
if (!nextTokenIsSmart(builder_, KW_IFX)) return false;
@@ -2472,7 +2652,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
result_ = consumeTokenSmart(builder_, KW_IFX);
result_ = result_ && expr(builder_, level_ + 1, -1);
result_ = result_ && ifxExpr_2(builder_, level_ + 1);
result_ = result_ && expr(builder_, level_ + 1, -1);
result_ = result_ && ifxExpr_3(builder_, level_ + 1);
result_ = result_ && ifxExpr_4(builder_, level_ + 1);
exit_section_(builder_, marker_, IFX_EXPR, result_);
return result_;
@@ -2485,6 +2665,13 @@ public class JaiParser implements PsiParser, LightPsiParser {
return true;
}
// [expr]
private static boolean ifxExpr_3(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ifxExpr_3")) return false;
expr(builder_, level_ + 1, -1);
return true;
}
// ['else' expr]
private static boolean ifxExpr_4(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ifxExpr_4")) return false;

10
src/main/gen/dev/hgh/jai/psi/JaiDeclName.java Normal file
View File

@@ -0,0 +1,10 @@
// This is a generated file. Not intended for manual editing.
package dev.hgh.jai.psi;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
public interface JaiDeclName extends PsiElement {
}

3
src/main/gen/dev/hgh/jai/psi/JaiDeclNames.java
View File

@@ -7,4 +7,7 @@ import com.intellij.psi.PsiElement;
public interface JaiDeclNames extends PsiElement {
@NotNull
List<JaiDeclName> getDeclNameList();
}

3
src/main/gen/dev/hgh/jai/psi/JaiDeclaration.java
View File

@@ -13,4 +13,7 @@ public interface JaiDeclaration extends PsiElement {
@Nullable
JaiInitializer getInitializer();
@NotNull
List<JaiProcModifier> getProcModifierList();
}

13
src/main/gen/dev/hgh/jai/psi/JaiDerefCastExpr.java Normal file
View File

@@ -0,0 +1,13 @@
// This is a generated file. Not intended for manual editing.
package dev.hgh.jai.psi;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
public interface JaiDerefCastExpr extends JaiExpr {
@Nullable
JaiExpr getExpr();
}

3
src/main/gen/dev/hgh/jai/psi/JaiDirectiveExpr.java
View File

@@ -13,4 +13,7 @@ public interface JaiDirectiveExpr extends JaiExpr {
@NotNull
List<JaiExpr> getExprList();
@NotNull
List<JaiParameter> getParameterList();
}

3
src/main/gen/dev/hgh/jai/psi/JaiReturnItem.java
View File

@@ -7,7 +7,4 @@ import com.intellij.psi.PsiElement;
public interface JaiReturnItem extends PsiElement {
@Nullable
JaiInitializer getInitializer();
}

8
src/main/gen/dev/hgh/jai/psi/JaiTypes.java
View File

@@ -28,8 +28,10 @@ public interface JaiTypes {
IElementType CAST_EXPR = new JaiElementType("CAST_EXPR");
IElementType CONTINUE_STATEMENT = new JaiElementType("CONTINUE_STATEMENT");
IElementType DECLARATION = new JaiElementType("DECLARATION");
IElementType DECL_NAME = new JaiElementType("DECL_NAME");
IElementType DECL_NAMES = new JaiElementType("DECL_NAMES");
IElementType DEFER_STATEMENT = new JaiElementType("DEFER_STATEMENT");
IElementType DEREF_CAST_EXPR = new JaiElementType("DEREF_CAST_EXPR");
IElementType DEREF_EXPR = new JaiElementType("DEREF_EXPR");
IElementType DIRECTIVE_EXPR = new JaiElementType("DIRECTIVE_EXPR");
IElementType DIRECTIVE_STATEMENT = new JaiElementType("DIRECTIVE_STATEMENT");
@@ -253,12 +255,18 @@ public interface JaiTypes {
else if (type == DECLARATION) {
return new JaiDeclarationImpl(node);
}
else if (type == DECL_NAME) {
return new JaiDeclNameImpl(node);
}
else if (type == DECL_NAMES) {
return new JaiDeclNamesImpl(node);
}
else if (type == DEFER_STATEMENT) {
return new JaiDeferStatementImpl(node);
}
else if (type == DEREF_CAST_EXPR) {
return new JaiDerefCastExprImpl(node);
}
else if (type == DEREF_EXPR) {
return new JaiDerefExprImpl(node);
}

8
src/main/gen/dev/hgh/jai/psi/JaiVisitor.java
View File

@@ -79,6 +79,10 @@ public class JaiVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitDeclName(@NotNull JaiDeclName o) {
visitPsiElement(o);
}
public void visitDeclNames(@NotNull JaiDeclNames o) {
visitPsiElement(o);
}
@@ -91,6 +95,10 @@ public class JaiVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitDerefCastExpr(@NotNull JaiDerefCastExpr o) {
visitExpr(o);
}
public void visitDerefExpr(@NotNull JaiDerefExpr o) {
visitExpr(o);
}

30
src/main/gen/dev/hgh/jai/psi/impl/JaiDeclNameImpl.java Normal file
View File

@@ -0,0 +1,30 @@
// This is a generated file. Not intended for manual editing.
package dev.hgh.jai.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static dev.hgh.jai.psi.JaiTypes.*;
import com.intellij.extapi.psi.ASTWrapperPsiElement;
import dev.hgh.jai.psi.*;
public class JaiDeclNameImpl extends ASTWrapperPsiElement implements JaiDeclName {
public JaiDeclNameImpl(@NotNull ASTNode node) {
super(node);
}
public void accept(@NotNull JaiVisitor visitor) {
visitor.visitDeclName(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof JaiVisitor) accept((JaiVisitor)visitor);
else super.accept(visitor);
}
}

6
src/main/gen/dev/hgh/jai/psi/impl/JaiDeclNamesImpl.java
View File

@@ -27,4 +27,10 @@ public class JaiDeclNamesImpl extends ASTWrapperPsiElement implements JaiDeclNam
else super.accept(visitor);
}
@Override
@NotNull
public List<JaiDeclName> getDeclNameList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiDeclName.class);
}
}

6
src/main/gen/dev/hgh/jai/psi/impl/JaiDeclarationImpl.java
View File

@@ -39,4 +39,10 @@ public class JaiDeclarationImpl extends ASTWrapperPsiElement implements JaiDecla
return findChildByClass(JaiInitializer.class);
}
@Override
@NotNull
public List<JaiProcModifier> getProcModifierList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiProcModifier.class);
}
}

36
src/main/gen/dev/hgh/jai/psi/impl/JaiDerefCastExprImpl.java Normal file
View File

@@ -0,0 +1,36 @@
// This is a generated file. Not intended for manual editing.
package dev.hgh.jai.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static dev.hgh.jai.psi.JaiTypes.*;
import dev.hgh.jai.psi.*;
public class JaiDerefCastExprImpl extends JaiExprImpl implements JaiDerefCastExpr {
public JaiDerefCastExprImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull JaiVisitor visitor) {
visitor.visitDerefCastExpr(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof JaiVisitor) accept((JaiVisitor)visitor);
else super.accept(visitor);
}
@Override
@Nullable
public JaiExpr getExpr() {
return findChildByClass(JaiExpr.class);
}
}

6
src/main/gen/dev/hgh/jai/psi/impl/JaiDirectiveExprImpl.java
View File

@@ -39,4 +39,10 @@ public class JaiDirectiveExprImpl extends JaiExprImpl implements JaiDirectiveExp
return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiExpr.class);
}
@Override
@NotNull
public List<JaiParameter> getParameterList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiParameter.class);
}
}

6
src/main/gen/dev/hgh/jai/psi/impl/JaiReturnItemImpl.java
View File

@@ -27,10 +27,4 @@ public class JaiReturnItemImpl extends ASTWrapperPsiElement implements JaiReturn
else super.accept(visitor);
}
@Override
@Nullable
public JaiInitializer getInitializer() {
return findChildByClass(JaiInitializer.class);
}
}