From 13f47fc078405123561a021a18bdf8a74b35887b Mon Sep 17 00:00:00 2001 From: Jaime Wren Date: Fri, 2 Jan 2026 13:50:32 -0800 Subject: [PATCH] feat: Update Dart BNF grammar and Grammar-Kit plugin - Update `org.jetbrains.grammarkit` to `2023.3.0.1`. - Regenerate parser and lexer files with the new plugin version. - Note: The new version introduces `recursion_guard_` and renames variables (e.g., `b` -> `builder_`) in the generated parser. - Configure `generateDartParser` task to include compiled classes (via `sourceSets["main"].output`) to correctly resolve `DartPsiImplUtil` methods during generation. - Add `verify-parser` job to `presubmit.yaml` to ensure generated files are up-to-date. - Runs `./gradlew classes` before generation to ensure dependencies are built. - Remove `_DartDocLexer` as it is now handled by the main lexer generation. --- .github/workflows/presubmit.yaml | 26 + third_party/build.gradle.kts | 35 + .../com/jetbrains/lang/dart/DartParser.java | 12520 ++++++++-------- .../lang/dart/lexer/_DartDocLexer.java | 4 +- .../jetbrains/lang/dart/lexer/_DartLexer.java | 2 +- 5 files changed, 6324 insertions(+), 6263 deletions(-) diff --git a/.github/workflows/presubmit.yaml b/.github/workflows/presubmit.yaml index 26e853147..f0d46fb30 100644 --- a/.github/workflows/presubmit.yaml +++ b/.github/workflows/presubmit.yaml @@ -126,3 +126,29 @@ jobs: ./gradlew verifyPluginSignature ./gradlew verifyPluginStructure working-directory: third_party + + # Job 5: Verify Parser + verify-parser: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up JDK + uses: actions/setup-java@v4 + with: + distribution: 'temurin' + java-version: '21' + cache: 'gradle' + + - name: Verify BNF Parser Generation + run: | + ./gradlew classes + ./gradlew generateDart + if [[ -n $(git status --porcelain gen) ]]; then + echo "Error: Parser generation resulted in changes. Please run './gradlew generateDart' and commit the changes." + git status gen + exit 1 + fi + echo "BNF grammar verification passed." + working-directory: third_party diff --git a/third_party/build.gradle.kts b/third_party/build.gradle.kts index ac72cce92..76892f758 100644 --- a/third_party/build.gradle.kts +++ b/third_party/build.gradle.kts @@ -3,6 +3,9 @@ import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType import org.jetbrains.intellij.platform.gradle.TestFrameworkType import org.jetbrains.intellij.platform.gradle.models.ProductRelease import org.jetbrains.intellij.platform.gradle.tasks.VerifyPluginTask +import org.jetbrains.grammarkit.tasks.GenerateLexerTask +import org.jetbrains.grammarkit.tasks.GenerateParserTask +import org.jetbrains.kotlin.gradle.tasks.KotlinCompile // Specify UTF-8 for all compilations so we avoid Windows-1252. allprojects { @@ -12,6 +15,8 @@ allprojects { tasks.withType { systemProperty("file.encoding", "UTF-8") } + tasks.withType { + } } // Plugins - must be first @@ -20,8 +25,11 @@ plugins { id("org.jetbrains.kotlin.jvm") version "2.3.0" // Kotlin support id("org.jetbrains.intellij.platform") version "2.10.5" // IntelliJ Platform Gradle Plugin id("org.jetbrains.changelog") version "2.2.0" // Gradle Changelog Plugin + id("org.jetbrains.grammarkit") version "2023.3.0.1" } + + // Configure project's dependencies repositories { mavenCentral() @@ -156,3 +164,30 @@ tasks.register("printCompileClasspath") { println("--- End Compile Classpath ---") } } + +tasks.register("generateDartParser", GenerateParserTask::class) { + sourceFile.set(file("src/main/java/com/jetbrains/lang/dart/Dart.bnf")) + targetRootOutputDir.set(file("build/gen_temp")) + pathToParser.set("com/jetbrains/lang/dart/DartParser.java") + pathToPsiRoot.set("com/jetbrains/lang/dart/psi") + purgeOldFiles.set(true) + classpath = sourceSets["main"].output + sourceSets["main"].compileClasspath +} + +tasks.register("generateDartLexer", GenerateLexerTask::class) { + sourceFile.set(file("src/main/java/com/jetbrains/lang/dart/lexer/Dart.flex")) + targetOutputDir.set(file("build/gen_temp/com/jetbrains/lang/dart/lexer")) + purgeOldFiles.set(true) +} + +tasks.register("generateDartDocLexer", GenerateLexerTask::class) { + sourceFile.set(file("src/main/java/com/jetbrains/lang/dart/lexer/DartDoc.flex")) + targetOutputDir.set(file("build/gen_temp/com/jetbrains/lang/dart/lexer")) + purgeOldFiles.set(true) +} + +tasks.register("generateDart", Copy::class) { + dependsOn("generateDartParser", "generateDartLexer", "generateDartDocLexer") + from("build/gen_temp") + into("gen") +} diff --git a/third_party/gen/com/jetbrains/lang/dart/DartParser.java b/third_party/gen/com/jetbrains/lang/dart/DartParser.java index a5afed2da..17dc62f66 100644 --- a/third_party/gen/com/jetbrains/lang/dart/DartParser.java +++ b/third_party/gen/com/jetbrains/lang/dart/DartParser.java @@ -14,32 +14,32 @@ @SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"}) public class DartParser implements PsiParser, LightPsiParser { - public ASTNode parse(IElementType t, PsiBuilder b) { - parseLight(t, b); - return b.getTreeBuilt(); + public ASTNode parse(IElementType root_, PsiBuilder builder_) { + parseLight(root_, builder_); + return builder_.getTreeBuilt(); } - public void parseLight(IElementType t, PsiBuilder b) { - boolean r; - b = adapt_builder_(t, b, this, EXTENDS_SETS_); - Marker m = enter_section_(b, 0, _COLLAPSE_, null); - r = parse_root_(t, b); - exit_section_(b, 0, m, t, r, true, TRUE_CONDITION); + public void parseLight(IElementType root_, PsiBuilder builder_) { + boolean result_; + builder_ = adapt_builder_(root_, builder_, this, EXTENDS_SETS_); + Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null); + result_ = parse_root_(root_, builder_); + exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION); } - protected boolean parse_root_(IElementType t, PsiBuilder b) { - return parse_root_(t, b, 0); + protected boolean parse_root_(IElementType root_, PsiBuilder builder_) { + return parse_root_(root_, builder_, 0); } - static boolean parse_root_(IElementType t, PsiBuilder b, int l) { - boolean r; - if (t == BLOCK) { - r = block(b, l + 1); + static boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) { + boolean result_; + if (root_ == BLOCK) { + result_ = block(builder_, level_ + 1); } else { - r = dartUnit(b, l + 1); + result_ = dartUnit(builder_, level_ + 1); } - return r; + return result_; } public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] { @@ -57,467 +57,467 @@ static boolean parse_root_(IElementType t, PsiBuilder b, int l) { /* ********************************************************** */ // additiveOperator multiplicativeExpressionWrapper - public static boolean additiveExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "additiveExpression")) return false; - if (!nextTokenIs(b, "", MINUS, PLUS)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, ADDITIVE_EXPRESSION, ""); - r = additiveOperator(b, l + 1); - r = r && multiplicativeExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean additiveExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "additiveExpression")) return false; + if (!nextTokenIs(builder_, "", MINUS, PLUS)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, ADDITIVE_EXPRESSION, ""); + result_ = additiveOperator(builder_, level_ + 1); + result_ = result_ && multiplicativeExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // multiplicativeExpressionWrapper additiveExpression* - static boolean additiveExpressionWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "additiveExpressionWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = multiplicativeExpressionWrapper(b, l + 1); - r = r && additiveExpressionWrapper_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean additiveExpressionWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "additiveExpressionWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = multiplicativeExpressionWrapper(builder_, level_ + 1); + result_ = result_ && additiveExpressionWrapper_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // additiveExpression* - private static boolean additiveExpressionWrapper_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "additiveExpressionWrapper_1")) return false; + private static boolean additiveExpressionWrapper_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "additiveExpressionWrapper_1")) return false; while (true) { - int c = current_position_(b); - if (!additiveExpression(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "additiveExpressionWrapper_1", c)) break; + int pos_ = current_position_(builder_); + if (!additiveExpression(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "additiveExpressionWrapper_1", pos_)) break; } return true; } /* ********************************************************** */ // '+' | '-' - public static boolean additiveOperator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "additiveOperator")) return false; - if (!nextTokenIs(b, "", MINUS, PLUS)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, ADDITIVE_OPERATOR, ""); - r = consumeToken(b, PLUS); - if (!r) r = consumeToken(b, MINUS); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean additiveOperator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "additiveOperator")) return false; + if (!nextTokenIs(builder_, "", MINUS, PLUS)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ADDITIVE_OPERATOR, ""); + result_ = consumeToken(builder_, PLUS); + if (!result_) result_ = consumeToken(builder_, MINUS); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // argumentListPart (',' argumentListPart)* ','? - public static boolean argumentList(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argumentList")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, ARGUMENT_LIST, ""); - r = argumentListPart(b, l + 1); - r = r && argumentList_1(b, l + 1); - r = r && argumentList_2(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::argument_list_recover); - return r; + public static boolean argumentList(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argumentList")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ARGUMENT_LIST, ""); + result_ = argumentListPart(builder_, level_ + 1); + result_ = result_ && argumentList_1(builder_, level_ + 1); + result_ = result_ && argumentList_2(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::argument_list_recover); + return result_; } // (',' argumentListPart)* - private static boolean argumentList_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argumentList_1")) return false; + private static boolean argumentList_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argumentList_1")) return false; while (true) { - int c = current_position_(b); - if (!argumentList_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "argumentList_1", c)) break; + int pos_ = current_position_(builder_); + if (!argumentList_1_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "argumentList_1", pos_)) break; } return true; } // ',' argumentListPart - private static boolean argumentList_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argumentList_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && argumentListPart(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean argumentList_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argumentList_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && argumentListPart(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean argumentList_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argumentList_2")) return false; - consumeToken(b, COMMA); + private static boolean argumentList_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argumentList_2")) return false; + consumeToken(builder_, COMMA); return true; } /* ********************************************************** */ // namedArgument | expression - static boolean argumentListPart(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argumentListPart")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = namedArgument(b, l + 1); - if (!r) r = expression(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::argument_list_part_recover); - return r; + static boolean argumentListPart(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argumentListPart")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = namedArgument(builder_, level_ + 1); + if (!result_) result_ = expression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::argument_list_part_recover); + return result_; } /* ********************************************************** */ // !(')' | ',') - static boolean argument_list_part_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argument_list_part_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !argument_list_part_recover_0(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + static boolean argument_list_part_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argument_list_part_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !argument_list_part_recover_0(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // ')' | ',' - private static boolean argument_list_part_recover_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argument_list_part_recover_0")) return false; - boolean r; - r = consumeToken(b, RPAREN); - if (!r) r = consumeToken(b, COMMA); - return r; + private static boolean argument_list_part_recover_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argument_list_part_recover_0")) return false; + boolean result_; + result_ = consumeToken(builder_, RPAREN); + if (!result_) result_ = consumeToken(builder_, COMMA); + return result_; } /* ********************************************************** */ // !(')') - static boolean argument_list_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "argument_list_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !consumeToken(b, RPAREN); - exit_section_(b, l, m, r, false, null); - return r; + static boolean argument_list_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "argument_list_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !consumeToken(builder_, RPAREN); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // '(' argumentList? ')' - public static boolean arguments(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arguments")) return false; - if (!nextTokenIs(b, LPAREN)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, ARGUMENTS, null); - r = consumeToken(b, LPAREN); - p = r; // pin = 1 - r = r && report_error_(b, arguments_1(b, l + 1)); - r = p && consumeToken(b, RPAREN) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean arguments(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arguments")) return false; + if (!nextTokenIs(builder_, LPAREN)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ARGUMENTS, null); + result_ = consumeToken(builder_, LPAREN); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, arguments_1(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, RPAREN) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // argumentList? - private static boolean arguments_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arguments_1")) return false; - argumentList(b, l + 1); + private static boolean arguments_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arguments_1")) return false; + argumentList(builder_, level_ + 1); return true; } /* ********************************************************** */ // !('?' '[' elements? ']' callOrArrayAccessOrQualifiedRefExpression ':') ('?.' | '?')? '[' expression? ']' - static boolean arrayAccess(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess")) return false; - if (!nextTokenIs(b, "", LBRACKET, QUEST, QUEST_DOT)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = arrayAccess_0(b, l + 1); - r = r && arrayAccess_1(b, l + 1); - r = r && consumeToken(b, LBRACKET); - p = r; // pin = 3 - r = r && report_error_(b, arrayAccess_3(b, l + 1)); - r = p && consumeToken(b, RBRACKET) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean arrayAccess(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess")) return false; + if (!nextTokenIs(builder_, "", LBRACKET, QUEST, QUEST_DOT)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = arrayAccess_0(builder_, level_ + 1); + result_ = result_ && arrayAccess_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, LBRACKET); + pinned_ = result_; // pin = 3 + result_ = result_ && report_error_(builder_, arrayAccess_3(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, RBRACKET) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // !('?' '[' elements? ']' callOrArrayAccessOrQualifiedRefExpression ':') - private static boolean arrayAccess_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_0")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !arrayAccess_0_0(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + private static boolean arrayAccess_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !arrayAccess_0_0(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // '?' '[' elements? ']' callOrArrayAccessOrQualifiedRefExpression ':' - private static boolean arrayAccess_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, QUEST, LBRACKET); - r = r && arrayAccess_0_0_2(b, l + 1); - r = r && consumeToken(b, RBRACKET); - r = r && callOrArrayAccessOrQualifiedRefExpression(b, l + 1); - r = r && consumeToken(b, COLON); - exit_section_(b, m, null, r); - return r; + private static boolean arrayAccess_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, QUEST, LBRACKET); + result_ = result_ && arrayAccess_0_0_2(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RBRACKET); + result_ = result_ && callOrArrayAccessOrQualifiedRefExpression(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, COLON); + exit_section_(builder_, marker_, null, result_); + return result_; } // elements? - private static boolean arrayAccess_0_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_0_0_2")) return false; - elements(b, l + 1); + private static boolean arrayAccess_0_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_0_0_2")) return false; + elements(builder_, level_ + 1); return true; } // ('?.' | '?')? - private static boolean arrayAccess_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_1")) return false; - arrayAccess_1_0(b, l + 1); + private static boolean arrayAccess_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_1")) return false; + arrayAccess_1_0(builder_, level_ + 1); return true; } // '?.' | '?' - private static boolean arrayAccess_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_1_0")) return false; - boolean r; - r = consumeToken(b, QUEST_DOT); - if (!r) r = consumeToken(b, QUEST); - return r; + private static boolean arrayAccess_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_1_0")) return false; + boolean result_; + result_ = consumeToken(builder_, QUEST_DOT); + if (!result_) result_ = consumeToken(builder_, QUEST); + return result_; } // expression? - private static boolean arrayAccess_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccess_3")) return false; - expression(b, l + 1); + private static boolean arrayAccess_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccess_3")) return false; + expression(builder_, level_ + 1); return true; } /* ********************************************************** */ // arrayAccess - public static boolean arrayAccessExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrayAccessExpression")) return false; - if (!nextTokenIs(b, "", LBRACKET, QUEST, QUEST_DOT)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, ARRAY_ACCESS_EXPRESSION, ""); - r = arrayAccess(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean arrayAccessExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrayAccessExpression")) return false; + if (!nextTokenIs(builder_, "", LBRACKET, QUEST, QUEST_DOT)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, ARRAY_ACCESS_EXPRESSION, ""); + result_ = arrayAccess(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // ('async' '*'? | 'sync' '*'?)? '=>' expression - static boolean arrowBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody")) return false; - if (!nextTokenIs(b, "", ASYNC, EXPRESSION_BODY_DEF, SYNC)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = arrowBody_0(b, l + 1); - r = r && consumeToken(b, EXPRESSION_BODY_DEF); - p = r; // pin = 2 - r = r && expression(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean arrowBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody")) return false; + if (!nextTokenIs(builder_, "", ASYNC, EXPRESSION_BODY_DEF, SYNC)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = arrowBody_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EXPRESSION_BODY_DEF); + pinned_ = result_; // pin = 2 + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // ('async' '*'? | 'sync' '*'?)? - private static boolean arrowBody_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0")) return false; - arrowBody_0_0(b, l + 1); + private static boolean arrowBody_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0")) return false; + arrowBody_0_0(builder_, level_ + 1); return true; } // 'async' '*'? | 'sync' '*'? - private static boolean arrowBody_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = arrowBody_0_0_0(b, l + 1); - if (!r) r = arrowBody_0_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean arrowBody_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = arrowBody_0_0_0(builder_, level_ + 1); + if (!result_) result_ = arrowBody_0_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'async' '*'? - private static boolean arrowBody_0_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, ASYNC); - r = r && arrowBody_0_0_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean arrowBody_0_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, ASYNC); + result_ = result_ && arrowBody_0_0_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '*'? - private static boolean arrowBody_0_0_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0_0_0_1")) return false; - consumeToken(b, MUL); + private static boolean arrowBody_0_0_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0_0_0_1")) return false; + consumeToken(builder_, MUL); return true; } // 'sync' '*'? - private static boolean arrowBody_0_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0_0_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SYNC); - r = r && arrowBody_0_0_1_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean arrowBody_0_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0_0_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SYNC); + result_ = result_ && arrowBody_0_0_1_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '*'? - private static boolean arrowBody_0_0_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBody_0_0_1_1")) return false; - consumeToken(b, MUL); + private static boolean arrowBody_0_0_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBody_0_0_1_1")) return false; + consumeToken(builder_, MUL); return true; } /* ********************************************************** */ // <> ';' - static boolean arrowBodyWithSemi(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arrowBodyWithSemi")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = arrowBodyWrapper(b, l + 1); - p = r; // pin = 1 - r = r && consumeToken(b, SEMICOLON); - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean arrowBodyWithSemi(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "arrowBodyWithSemi")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = arrowBodyWrapper(builder_, level_ + 1); + pinned_ = result_; // pin = 1 + result_ = result_ && consumeToken(builder_, SEMICOLON); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // 'as' type - public static boolean asExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "asExpression")) return false; - if (!nextTokenIs(b, AS)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, AS_EXPRESSION, null); - r = consumeToken(b, AS); - r = r && type(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean asExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "asExpression")) return false; + if (!nextTokenIs(builder_, AS)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, AS_EXPRESSION, null); + result_ = consumeToken(builder_, AS); + result_ = result_ && type(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // 'assert' '(' expressionWithRecoverUntilParenOrComma (',' expressionWithRecoverUntilParenOrComma)? ','? ')' - public static boolean assertStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assertStatement")) return false; - if (!nextTokenIs(b, ASSERT)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, ASSERT_STATEMENT, null); - r = consumeTokens(b, 1, ASSERT, LPAREN); - p = r; // pin = 1 - r = r && report_error_(b, expressionWithRecoverUntilParenOrComma(b, l + 1)); - r = p && report_error_(b, assertStatement_3(b, l + 1)) && r; - r = p && report_error_(b, assertStatement_4(b, l + 1)) && r; - r = p && consumeToken(b, RPAREN) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean assertStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assertStatement")) return false; + if (!nextTokenIs(builder_, ASSERT)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ASSERT_STATEMENT, null); + result_ = consumeTokens(builder_, 1, ASSERT, LPAREN); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, expressionWithRecoverUntilParenOrComma(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, assertStatement_3(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, assertStatement_4(builder_, level_ + 1)) && result_; + result_ = pinned_ && consumeToken(builder_, RPAREN) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // (',' expressionWithRecoverUntilParenOrComma)? - private static boolean assertStatement_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assertStatement_3")) return false; - assertStatement_3_0(b, l + 1); + private static boolean assertStatement_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assertStatement_3")) return false; + assertStatement_3_0(builder_, level_ + 1); return true; } // ',' expressionWithRecoverUntilParenOrComma - private static boolean assertStatement_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assertStatement_3_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && expressionWithRecoverUntilParenOrComma(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean assertStatement_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assertStatement_3_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && expressionWithRecoverUntilParenOrComma(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean assertStatement_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assertStatement_4")) return false; - consumeToken(b, COMMA); + private static boolean assertStatement_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assertStatement_4")) return false; + consumeToken(builder_, COMMA); return true; } /* ********************************************************** */ // assertStatement ';' - static boolean assertStatementWithSemicolon(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assertStatementWithSemicolon")) return false; - if (!nextTokenIs(b, ASSERT)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = assertStatement(b, l + 1); - p = r; // pin = 1 - r = r && consumeToken(b, SEMICOLON); - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean assertStatementWithSemicolon(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assertStatementWithSemicolon")) return false; + if (!nextTokenIs(builder_, ASSERT)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = assertStatement(builder_, level_ + 1); + pinned_ = result_; // pin = 1 + result_ = result_ && consumeToken(builder_, SEMICOLON); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // assignmentOperator ternaryExpressionWrapper - public static boolean assignExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assignExpression")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _LEFT_, ASSIGN_EXPRESSION, ""); - r = assignmentOperator(b, l + 1); - p = r; // pin = 1 - r = r && ternaryExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean assignExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assignExpression")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, ASSIGN_EXPRESSION, ""); + result_ = assignmentOperator(builder_, level_ + 1); + pinned_ = result_; // pin = 1 + result_ = result_ && ternaryExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // ternaryExpressionWrapper assignExpression* - static boolean assignExpressionWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assignExpressionWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = ternaryExpressionWrapper(b, l + 1); - r = r && assignExpressionWrapper_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean assignExpressionWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assignExpressionWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = ternaryExpressionWrapper(builder_, level_ + 1); + result_ = result_ && assignExpressionWrapper_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // assignExpression* - private static boolean assignExpressionWrapper_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assignExpressionWrapper_1")) return false; + private static boolean assignExpressionWrapper_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assignExpressionWrapper_1")) return false; while (true) { - int c = current_position_(b); - if (!assignExpression(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "assignExpressionWrapper_1", c)) break; + int pos_ = current_position_(builder_); + if (!assignExpression(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "assignExpressionWrapper_1", pos_)) break; } return true; } /* ********************************************************** */ // '=' | '*=' | '/=' | '~/=' | '%=' | '+=' | '-=' | '<<=' | <> | <> | '&=' | '&&=' | '^=' | '|=' | '||=' | '??=' - public static boolean assignmentOperator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assignmentOperator")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, ASSIGNMENT_OPERATOR, ""); - r = consumeToken(b, EQ); - if (!r) r = consumeToken(b, MUL_EQ); - if (!r) r = consumeToken(b, DIV_EQ); - if (!r) r = consumeToken(b, INT_DIV_EQ); - if (!r) r = consumeToken(b, REM_EQ); - if (!r) r = consumeToken(b, PLUS_EQ); - if (!r) r = consumeToken(b, MINUS_EQ); - if (!r) r = consumeToken(b, LT_LT_EQ); - if (!r) r = gtGtEq(b, l + 1); - if (!r) r = gtGtGtEq(b, l + 1); - if (!r) r = consumeToken(b, AND_EQ); - if (!r) r = consumeToken(b, AND_AND_EQ); - if (!r) r = consumeToken(b, XOR_EQ); - if (!r) r = consumeToken(b, OR_EQ); - if (!r) r = consumeToken(b, OR_OR_EQ); - if (!r) r = consumeToken(b, QUEST_QUEST_EQ); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean assignmentOperator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "assignmentOperator")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ASSIGNMENT_OPERATOR, ""); + result_ = consumeToken(builder_, EQ); + if (!result_) result_ = consumeToken(builder_, MUL_EQ); + if (!result_) result_ = consumeToken(builder_, DIV_EQ); + if (!result_) result_ = consumeToken(builder_, INT_DIV_EQ); + if (!result_) result_ = consumeToken(builder_, REM_EQ); + if (!result_) result_ = consumeToken(builder_, PLUS_EQ); + if (!result_) result_ = consumeToken(builder_, MINUS_EQ); + if (!result_) result_ = consumeToken(builder_, LT_LT_EQ); + if (!result_) result_ = gtGtEq(builder_, level_ + 1); + if (!result_) result_ = gtGtGtEq(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, AND_EQ); + if (!result_) result_ = consumeToken(builder_, AND_AND_EQ); + if (!result_) result_ = consumeToken(builder_, XOR_EQ); + if (!result_) result_ = consumeToken(builder_, OR_EQ); + if (!result_) result_ = consumeToken(builder_, OR_OR_EQ); + if (!result_) result_ = consumeToken(builder_, QUEST_QUEST_EQ); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // <> 'await' prefixExpression - public static boolean awaitExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "awaitExpression")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, AWAIT_EXPRESSION, ""); - r = isInsideSyncOrAsyncFunction(b, l + 1); - r = r && consumeToken(b, AWAIT); - r = r && prefixExpression(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean awaitExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "awaitExpression")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, AWAIT_EXPRESSION, ""); + result_ = isInsideSyncOrAsyncFunction(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, AWAIT); + result_ = result_ && prefixExpression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ @@ -527,388 +527,388 @@ public static boolean awaitExpression(PsiBuilder b, int l) { // relationalOperator| // '==' | // bitwiseOperator - static boolean binaryOperator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "binaryOperator")) return false; - boolean r; - r = multiplicativeOperator(b, l + 1); - if (!r) r = additiveOperator(b, l + 1); - if (!r) r = shiftOperator(b, l + 1); - if (!r) r = relationalOperator(b, l + 1); - if (!r) r = consumeToken(b, EQ_EQ); - if (!r) r = bitwiseOperator(b, l + 1); - return r; + static boolean binaryOperator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "binaryOperator")) return false; + boolean result_; + result_ = multiplicativeOperator(builder_, level_ + 1); + if (!result_) result_ = additiveOperator(builder_, level_ + 1); + if (!result_) result_ = shiftOperator(builder_, level_ + 1); + if (!result_) result_ = relationalOperator(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, EQ_EQ); + if (!result_) result_ = bitwiseOperator(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // bitwiseOperator shiftExpressionWrapper - public static boolean bitwiseExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "bitwiseExpression")) return false; - if (!nextTokenIs(b, "", AND, OR, XOR)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, BITWISE_EXPRESSION, ""); - r = bitwiseOperator(b, l + 1); - r = r && shiftExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean bitwiseExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "bitwiseExpression")) return false; + if (!nextTokenIs(builder_, "", AND, OR, XOR)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, BITWISE_EXPRESSION, ""); + result_ = bitwiseOperator(builder_, level_ + 1); + result_ = result_ && shiftExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // shiftExpressionWrapper bitwiseExpression* - static boolean bitwiseExpressionWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "bitwiseExpressionWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = shiftExpressionWrapper(b, l + 1); - r = r && bitwiseExpressionWrapper_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean bitwiseExpressionWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "bitwiseExpressionWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = shiftExpressionWrapper(builder_, level_ + 1); + result_ = result_ && bitwiseExpressionWrapper_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // bitwiseExpression* - private static boolean bitwiseExpressionWrapper_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "bitwiseExpressionWrapper_1")) return false; + private static boolean bitwiseExpressionWrapper_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "bitwiseExpressionWrapper_1")) return false; while (true) { - int c = current_position_(b); - if (!bitwiseExpression(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "bitwiseExpressionWrapper_1", c)) break; + int pos_ = current_position_(builder_); + if (!bitwiseExpression(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "bitwiseExpressionWrapper_1", pos_)) break; } return true; } /* ********************************************************** */ // '&' | '^' | '|' - public static boolean bitwiseOperator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "bitwiseOperator")) return false; - if (!nextTokenIs(b, "", AND, OR, XOR)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, BITWISE_OPERATOR, ""); - r = consumeToken(b, AND); - if (!r) r = consumeToken(b, XOR); - if (!r) r = consumeToken(b, OR); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean bitwiseOperator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "bitwiseOperator")) return false; + if (!nextTokenIs(builder_, "", AND, OR, XOR)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, BITWISE_OPERATOR, ""); + result_ = consumeToken(builder_, AND); + if (!result_) result_ = consumeToken(builder_, XOR); + if (!result_) result_ = consumeToken(builder_, OR); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // '{' statements '}' - public static boolean block(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "block")) return false; - if (!nextTokenIs(b, LBRACE)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, BLOCK, null); - r = consumeToken(b, LBRACE); - p = r; // pin = 1 - r = r && report_error_(b, statements(b, l + 1)); - r = p && consumeToken(b, RBRACE) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean block(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "block")) return false; + if (!nextTokenIs(builder_, LBRACE)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, BLOCK, null); + result_ = consumeToken(builder_, LBRACE); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, statements(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, RBRACE) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // ('async' '*'? | 'sync' '*'?)? lazyParseableBlock - static boolean blockBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody")) return false; - boolean r; - Marker m = enter_section_(b); - r = blockBody_0(b, l + 1); - r = r && lazyParseableBlock(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean blockBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = blockBody_0(builder_, level_ + 1); + result_ = result_ && lazyParseableBlock(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ('async' '*'? | 'sync' '*'?)? - private static boolean blockBody_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0")) return false; - blockBody_0_0(b, l + 1); + private static boolean blockBody_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0")) return false; + blockBody_0_0(builder_, level_ + 1); return true; } // 'async' '*'? | 'sync' '*'? - private static boolean blockBody_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = blockBody_0_0_0(b, l + 1); - if (!r) r = blockBody_0_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean blockBody_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = blockBody_0_0_0(builder_, level_ + 1); + if (!result_) result_ = blockBody_0_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'async' '*'? - private static boolean blockBody_0_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, ASYNC); - r = r && blockBody_0_0_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean blockBody_0_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, ASYNC); + result_ = result_ && blockBody_0_0_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '*'? - private static boolean blockBody_0_0_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0_0_0_1")) return false; - consumeToken(b, MUL); + private static boolean blockBody_0_0_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0_0_0_1")) return false; + consumeToken(builder_, MUL); return true; } // 'sync' '*'? - private static boolean blockBody_0_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0_0_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SYNC); - r = r && blockBody_0_0_1_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean blockBody_0_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0_0_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SYNC); + result_ = result_ && blockBody_0_0_1_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '*'? - private static boolean blockBody_0_0_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "blockBody_0_0_1_1")) return false; - consumeToken(b, MUL); + private static boolean blockBody_0_0_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "blockBody_0_0_1_1")) return false; + consumeToken(builder_, MUL); return true; } /* ********************************************************** */ // 'break' referenceExpression? ';' - public static boolean breakStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "breakStatement")) return false; - if (!nextTokenIs(b, BREAK)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, BREAK_STATEMENT, null); - r = consumeToken(b, BREAK); - p = r; // pin = 1 - r = r && report_error_(b, breakStatement_1(b, l + 1)); - r = p && consumeToken(b, SEMICOLON) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean breakStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "breakStatement")) return false; + if (!nextTokenIs(builder_, BREAK)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, BREAK_STATEMENT, null); + result_ = consumeToken(builder_, BREAK); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, breakStatement_1(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, SEMICOLON) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // referenceExpression? - private static boolean breakStatement_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "breakStatement_1")) return false; - referenceExpression(b, l + 1); + private static boolean breakStatement_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "breakStatement_1")) return false; + referenceExpression(builder_, level_ + 1); return true; } /* ********************************************************** */ // typeArguments? ('.' 'new')? <> - public static boolean callExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callExpression")) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, CALL_EXPRESSION, ""); - r = callExpression_0(b, l + 1); - r = r && callExpression_1(b, l + 1); - r = r && argumentsWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean callExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callExpression")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, CALL_EXPRESSION, ""); + result_ = callExpression_0(builder_, level_ + 1); + result_ = result_ && callExpression_1(builder_, level_ + 1); + result_ = result_ && argumentsWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // typeArguments? - private static boolean callExpression_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callExpression_0")) return false; - typeArguments(b, l + 1); + private static boolean callExpression_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callExpression_0")) return false; + typeArguments(builder_, level_ + 1); return true; } // ('.' 'new')? - private static boolean callExpression_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callExpression_1")) return false; - callExpression_1_0(b, l + 1); + private static boolean callExpression_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callExpression_1")) return false; + callExpression_1_0(builder_, level_ + 1); return true; } // '.' 'new' - private static boolean callExpression_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callExpression_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, DOT, NEW); - exit_section_(b, m, null, r); - return r; + private static boolean callExpression_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callExpression_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, DOT, NEW); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // (callExpression | arrayAccessExpression | qualifiedReferenceExpression | '!' | typeArguments)* - static boolean callOrArrayAccessOrQualifiedRefExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callOrArrayAccessOrQualifiedRefExpression")) return false; + static boolean callOrArrayAccessOrQualifiedRefExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callOrArrayAccessOrQualifiedRefExpression")) return false; while (true) { - int c = current_position_(b); - if (!callOrArrayAccessOrQualifiedRefExpression_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "callOrArrayAccessOrQualifiedRefExpression", c)) break; + int pos_ = current_position_(builder_); + if (!callOrArrayAccessOrQualifiedRefExpression_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "callOrArrayAccessOrQualifiedRefExpression", pos_)) break; } return true; } // callExpression | arrayAccessExpression | qualifiedReferenceExpression | '!' | typeArguments - private static boolean callOrArrayAccessOrQualifiedRefExpression_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "callOrArrayAccessOrQualifiedRefExpression_0")) return false; - boolean r; - r = callExpression(b, l + 1); - if (!r) r = arrayAccessExpression(b, l + 1); - if (!r) r = qualifiedReferenceExpression(b, l + 1); - if (!r) r = consumeToken(b, NOT); - if (!r) r = typeArguments(b, l + 1); - return r; + private static boolean callOrArrayAccessOrQualifiedRefExpression_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "callOrArrayAccessOrQualifiedRefExpression_0")) return false; + boolean result_; + result_ = callExpression(builder_, level_ + 1); + if (!result_) result_ = arrayAccessExpression(builder_, level_ + 1); + if (!result_) result_ = qualifiedReferenceExpression(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, NOT); + if (!result_) result_ = typeArguments(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // ('?..' | '..') << cascadeStopper >> (arrayAccess | refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression) << varInitWrapper >> - public static boolean cascadeReferenceExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "cascadeReferenceExpression")) return false; - if (!nextTokenIs(b, "", DOT_DOT, QUEST_DOT_DOT)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, CASCADE_REFERENCE_EXPRESSION, ""); - r = cascadeReferenceExpression_0(b, l + 1); - r = r && cascadeStopper(b, l + 1); - r = r && cascadeReferenceExpression_2(b, l + 1); - r = r && varInitWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean cascadeReferenceExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "cascadeReferenceExpression")) return false; + if (!nextTokenIs(builder_, "", DOT_DOT, QUEST_DOT_DOT)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CASCADE_REFERENCE_EXPRESSION, ""); + result_ = cascadeReferenceExpression_0(builder_, level_ + 1); + result_ = result_ && cascadeStopper(builder_, level_ + 1); + result_ = result_ && cascadeReferenceExpression_2(builder_, level_ + 1); + result_ = result_ && varInitWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // '?..' | '..' - private static boolean cascadeReferenceExpression_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "cascadeReferenceExpression_0")) return false; - boolean r; - r = consumeToken(b, QUEST_DOT_DOT); - if (!r) r = consumeToken(b, DOT_DOT); - return r; + private static boolean cascadeReferenceExpression_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "cascadeReferenceExpression_0")) return false; + boolean result_; + result_ = consumeToken(builder_, QUEST_DOT_DOT); + if (!result_) result_ = consumeToken(builder_, DOT_DOT); + return result_; } // arrayAccess | refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression - private static boolean cascadeReferenceExpression_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "cascadeReferenceExpression_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = arrayAccess(b, l + 1); - if (!r) r = cascadeReferenceExpression_2_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean cascadeReferenceExpression_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "cascadeReferenceExpression_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = arrayAccess(builder_, level_ + 1); + if (!result_) result_ = cascadeReferenceExpression_2_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression - private static boolean cascadeReferenceExpression_2_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "cascadeReferenceExpression_2_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = refOrThisOrSuperOrParenExpression(b, l + 1); - r = r && callOrArrayAccessOrQualifiedRefExpression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean cascadeReferenceExpression_2_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "cascadeReferenceExpression_2_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = refOrThisOrSuperOrParenExpression(builder_, level_ + 1); + result_ = result_ && callOrArrayAccessOrQualifiedRefExpression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'catch' '(' componentName (',' componentName)? ')' - public static boolean catchPart(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "catchPart")) return false; - if (!nextTokenIs(b, CATCH)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, CATCH_PART, null); - r = consumeTokens(b, 1, CATCH, LPAREN); - p = r; // pin = 1 - r = r && report_error_(b, componentName(b, l + 1)); - r = p && report_error_(b, catchPart_3(b, l + 1)) && r; - r = p && consumeToken(b, RPAREN) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean catchPart(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "catchPart")) return false; + if (!nextTokenIs(builder_, CATCH)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CATCH_PART, null); + result_ = consumeTokens(builder_, 1, CATCH, LPAREN); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, componentName(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, catchPart_3(builder_, level_ + 1)) && result_; + result_ = pinned_ && consumeToken(builder_, RPAREN) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // (',' componentName)? - private static boolean catchPart_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "catchPart_3")) return false; - catchPart_3_0(b, l + 1); + private static boolean catchPart_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "catchPart_3")) return false; + catchPart_3_0(builder_, level_ + 1); return true; } // ',' componentName - private static boolean catchPart_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "catchPart_3_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean catchPart_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "catchPart_3_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // '{' classMembers '}' - public static boolean classBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classBody")) return false; - if (!nextTokenIs(b, LBRACE)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, CLASS_BODY, null); - r = consumeToken(b, LBRACE); - p = r; // pin = 1 - r = r && report_error_(b, classMembers(b, l + 1)); - r = p && consumeToken(b, RBRACE) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean classBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classBody")) return false; + if (!nextTokenIs(builder_, LBRACE)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CLASS_BODY, null); + result_ = consumeToken(builder_, LBRACE); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, classMembers(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, RBRACE) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // metadata* 'augment'? (mixinClassModifiers | classModifiers) 'class' componentName typeParameters? (mixinApplication | standardClassDeclarationTail) - public static boolean classDefinition(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition")) return false; - if (!nextTokenIs(b, "", ABSTRACT, AT, + public static boolean classDefinition(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition")) return false; + if (!nextTokenIs(builder_, "", ABSTRACT, AT, AUGMENT, BASE, CLASS, FINAL, INTERFACE, MACRO, MIXIN, SEALED)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, CLASS_DEFINITION, ""); - r = classDefinition_0(b, l + 1); - r = r && classDefinition_1(b, l + 1); - r = r && classDefinition_2(b, l + 1); - r = r && consumeToken(b, CLASS); - r = r && componentName(b, l + 1); - p = r; // pin = 5 - r = r && report_error_(b, classDefinition_5(b, l + 1)); - r = p && classDefinition_6(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CLASS_DEFINITION, ""); + result_ = classDefinition_0(builder_, level_ + 1); + result_ = result_ && classDefinition_1(builder_, level_ + 1); + result_ = result_ && classDefinition_2(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, CLASS); + result_ = result_ && componentName(builder_, level_ + 1); + pinned_ = result_; // pin = 5 + result_ = result_ && report_error_(builder_, classDefinition_5(builder_, level_ + 1)); + result_ = pinned_ && classDefinition_6(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean classDefinition_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition_0")) return false; + private static boolean classDefinition_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "classDefinition_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "classDefinition_0", pos_)) break; } return true; } // 'augment'? - private static boolean classDefinition_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition_1")) return false; - consumeToken(b, AUGMENT); + private static boolean classDefinition_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // mixinClassModifiers | classModifiers - private static boolean classDefinition_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition_2")) return false; - boolean r; - r = mixinClassModifiers(b, l + 1); - if (!r) r = classModifiers(b, l + 1); - return r; + private static boolean classDefinition_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition_2")) return false; + boolean result_; + result_ = mixinClassModifiers(builder_, level_ + 1); + if (!result_) result_ = classModifiers(builder_, level_ + 1); + return result_; } // typeParameters? - private static boolean classDefinition_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition_5")) return false; - typeParameters(b, l + 1); + private static boolean classDefinition_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition_5")) return false; + typeParameters(builder_, level_ + 1); return true; } // mixinApplication | standardClassDeclarationTail - private static boolean classDefinition_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classDefinition_6")) return false; - boolean r; - r = mixinApplication(b, l + 1); - if (!r) r = standardClassDeclarationTail(b, l + 1); - return r; + private static boolean classDefinition_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classDefinition_6")) return false; + boolean result_; + result_ = mixinApplication(builder_, level_ + 1); + if (!result_) result_ = standardClassDeclarationTail(builder_, level_ + 1); + return result_; } /* ********************************************************** */ @@ -918,213 +918,213 @@ private static boolean classDefinition_6(PsiBuilder b, int l) { // | methodDeclaration // | varDeclarationListWithSemicolon // | incompleteDeclaration - static boolean classMemberDefinition(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classMemberDefinition")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = factoryConstructorDeclaration(b, l + 1); - if (!r) r = namedConstructorDeclaration(b, l + 1); - if (!r) r = getterOrSetterDeclaration(b, l + 1); - if (!r) r = methodDeclaration(b, l + 1); - if (!r) r = varDeclarationListWithSemicolon(b, l + 1); - if (!r) r = incompleteDeclaration(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::class_member_recover); - return r; + static boolean classMemberDefinition(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classMemberDefinition")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = factoryConstructorDeclaration(builder_, level_ + 1); + if (!result_) result_ = namedConstructorDeclaration(builder_, level_ + 1); + if (!result_) result_ = getterOrSetterDeclaration(builder_, level_ + 1); + if (!result_) result_ = methodDeclaration(builder_, level_ + 1); + if (!result_) result_ = varDeclarationListWithSemicolon(builder_, level_ + 1); + if (!result_) result_ = incompleteDeclaration(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::class_member_recover); + return result_; } /* ********************************************************** */ // classMemberDefinition* - public static boolean classMembers(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classMembers")) return false; - Marker m = enter_section_(b, l, _NONE_, CLASS_MEMBERS, ""); + public static boolean classMembers(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classMembers")) return false; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CLASS_MEMBERS, ""); while (true) { - int c = current_position_(b); - if (!classMemberDefinition(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "classMembers", c)) break; + int pos_ = current_position_(builder_); + if (!classMemberDefinition(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "classMembers", pos_)) break; } - exit_section_(b, l, m, true, false, DartParser::simple_scope_recover); + exit_section_(builder_, level_, marker_, true, false, DartParser::simple_scope_recover); return true; } /* ********************************************************** */ // 'sealed' | 'macro' | 'abstract'? ('base' | 'interface' | 'final')? - static boolean classModifiers(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classModifiers")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEALED); - if (!r) r = consumeToken(b, MACRO); - if (!r) r = classModifiers_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean classModifiers(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classModifiers")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEALED); + if (!result_) result_ = consumeToken(builder_, MACRO); + if (!result_) result_ = classModifiers_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'abstract'? ('base' | 'interface' | 'final')? - private static boolean classModifiers_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classModifiers_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = classModifiers_2_0(b, l + 1); - r = r && classModifiers_2_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean classModifiers_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classModifiers_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = classModifiers_2_0(builder_, level_ + 1); + result_ = result_ && classModifiers_2_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'abstract'? - private static boolean classModifiers_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classModifiers_2_0")) return false; - consumeToken(b, ABSTRACT); + private static boolean classModifiers_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classModifiers_2_0")) return false; + consumeToken(builder_, ABSTRACT); return true; } // ('base' | 'interface' | 'final')? - private static boolean classModifiers_2_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classModifiers_2_1")) return false; - classModifiers_2_1_0(b, l + 1); + private static boolean classModifiers_2_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classModifiers_2_1")) return false; + classModifiers_2_1_0(builder_, level_ + 1); return true; } // 'base' | 'interface' | 'final' - private static boolean classModifiers_2_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "classModifiers_2_1_0")) return false; - boolean r; - r = consumeToken(b, BASE); - if (!r) r = consumeToken(b, INTERFACE); - if (!r) r = consumeToken(b, FINAL); - return r; + private static boolean classModifiers_2_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "classModifiers_2_1_0")) return false; + boolean result_; + result_ = consumeToken(builder_, BASE); + if (!result_) result_ = consumeToken(builder_, INTERFACE); + if (!result_) result_ = consumeToken(builder_, FINAL); + return result_; } /* ********************************************************** */ // !(<> | 'operator' | '(' | '@' | 'abstract' | 'base' | 'class' | 'const' | 'covariant' | // 'enum' | 'export' | 'extension' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'interface' | // 'late' | 'library' | 'mixin' | 'part' | 'sealed' | 'set' | 'static' | 'typedef' | 'var' | 'void' | '}') - static boolean class_member_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "class_member_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !class_member_recover_0(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + static boolean class_member_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "class_member_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !class_member_recover_0(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // <> | 'operator' | '(' | '@' | 'abstract' | 'base' | 'class' | 'const' | 'covariant' | // 'enum' | 'export' | 'extension' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'interface' | // 'late' | 'library' | 'mixin' | 'part' | 'sealed' | 'set' | 'static' | 'typedef' | 'var' | 'void' | '}' - private static boolean class_member_recover_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "class_member_recover_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = nonStrictID(b, l + 1); - if (!r) r = consumeToken(b, OPERATOR); - if (!r) r = consumeToken(b, LPAREN); - if (!r) r = consumeToken(b, AT); - if (!r) r = consumeToken(b, ABSTRACT); - if (!r) r = consumeToken(b, BASE); - if (!r) r = consumeToken(b, CLASS); - if (!r) r = consumeToken(b, CONST); - if (!r) r = consumeToken(b, COVARIANT); - if (!r) r = consumeToken(b, ENUM); - if (!r) r = consumeToken(b, EXPORT); - if (!r) r = consumeToken(b, EXTENSION); - if (!r) r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, FACTORY); - if (!r) r = consumeToken(b, FINAL); - if (!r) r = consumeToken(b, GET); - if (!r) r = consumeToken(b, IMPORT); - if (!r) r = consumeToken(b, INTERFACE); - if (!r) r = consumeToken(b, LATE); - if (!r) r = consumeToken(b, LIBRARY); - if (!r) r = consumeToken(b, MIXIN); - if (!r) r = consumeToken(b, PART); - if (!r) r = consumeToken(b, SEALED); - if (!r) r = consumeToken(b, SET); - if (!r) r = consumeToken(b, STATIC); - if (!r) r = consumeToken(b, TYPEDEF); - if (!r) r = consumeToken(b, VAR); - if (!r) r = consumeToken(b, VOID); - if (!r) r = consumeToken(b, RBRACE); - exit_section_(b, m, null, r); - return r; + private static boolean class_member_recover_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "class_member_recover_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = nonStrictID(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, OPERATOR); + if (!result_) result_ = consumeToken(builder_, LPAREN); + if (!result_) result_ = consumeToken(builder_, AT); + if (!result_) result_ = consumeToken(builder_, ABSTRACT); + if (!result_) result_ = consumeToken(builder_, BASE); + if (!result_) result_ = consumeToken(builder_, CLASS); + if (!result_) result_ = consumeToken(builder_, CONST); + if (!result_) result_ = consumeToken(builder_, COVARIANT); + if (!result_) result_ = consumeToken(builder_, ENUM); + if (!result_) result_ = consumeToken(builder_, EXPORT); + if (!result_) result_ = consumeToken(builder_, EXTENSION); + if (!result_) result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, FACTORY); + if (!result_) result_ = consumeToken(builder_, FINAL); + if (!result_) result_ = consumeToken(builder_, GET); + if (!result_) result_ = consumeToken(builder_, IMPORT); + if (!result_) result_ = consumeToken(builder_, INTERFACE); + if (!result_) result_ = consumeToken(builder_, LATE); + if (!result_) result_ = consumeToken(builder_, LIBRARY); + if (!result_) result_ = consumeToken(builder_, MIXIN); + if (!result_) result_ = consumeToken(builder_, PART); + if (!result_) result_ = consumeToken(builder_, SEALED); + if (!result_) result_ = consumeToken(builder_, SET); + if (!result_) result_ = consumeToken(builder_, STATIC); + if (!result_) result_ = consumeToken(builder_, TYPEDEF); + if (!result_) result_ = consumeToken(builder_, VAR); + if (!result_) result_ = consumeToken(builder_, VOID); + if (!result_) result_ = consumeToken(builder_, RBRACE); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // showCombinator | hideCombinator - static boolean combinator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "combinator")) return false; - if (!nextTokenIs(b, "", HIDE, SHOW)) return false; - boolean r; - r = showCombinator(b, l + 1); - if (!r) r = hideCombinator(b, l + 1); - return r; + static boolean combinator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "combinator")) return false; + if (!nextTokenIs(builder_, "", HIDE, SHOW)) return false; + boolean result_; + result_ = showCombinator(builder_, level_ + 1); + if (!result_) result_ = hideCombinator(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // (relationalOperator | equalityOperator) bitwiseExpressionWrapper - public static boolean compareExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "compareExpression")) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, COMPARE_EXPRESSION, ""); - r = compareExpression_0(b, l + 1); - r = r && bitwiseExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean compareExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "compareExpression")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, COMPARE_EXPRESSION, ""); + result_ = compareExpression_0(builder_, level_ + 1); + result_ = result_ && bitwiseExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // relationalOperator | equalityOperator - private static boolean compareExpression_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "compareExpression_0")) return false; - boolean r; - r = relationalOperator(b, l + 1); - if (!r) r = equalityOperator(b, l + 1); - return r; + private static boolean compareExpression_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "compareExpression_0")) return false; + boolean result_; + result_ = relationalOperator(builder_, level_ + 1); + if (!result_) result_ = equalityOperator(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // bitwiseExpressionWrapper compareExpression* - static boolean compareExpressionWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "compareExpressionWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = bitwiseExpressionWrapper(b, l + 1); - r = r && compareExpressionWrapper_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean compareExpressionWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "compareExpressionWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = bitwiseExpressionWrapper(builder_, level_ + 1); + result_ = result_ && compareExpressionWrapper_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // compareExpression* - private static boolean compareExpressionWrapper_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "compareExpressionWrapper_1")) return false; + private static boolean compareExpressionWrapper_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "compareExpressionWrapper_1")) return false; while (true) { - int c = current_position_(b); - if (!compareExpression(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "compareExpressionWrapper_1", c)) break; + int pos_ = current_position_(builder_); + if (!compareExpression(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "compareExpressionWrapper_1", pos_)) break; } return true; } /* ********************************************************** */ // << nonStrictID >> - public static boolean componentName(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "componentName")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, COMPONENT_NAME, ""); - r = nonStrictID(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean componentName(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "componentName")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, COMPONENT_NAME, ""); + result_ = nonStrictID(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // 'const' constructorDesignation arguments - public static boolean constObjectExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constObjectExpression")) return false; - if (!nextTokenIs(b, CONST)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, CONST); - r = r && constructorDesignation(b, l + 1); - r = r && arguments(b, l + 1); - exit_section_(b, m, CONST_OBJECT_EXPRESSION, r); - return r; + public static boolean constObjectExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constObjectExpression")) return false; + if (!nextTokenIs(builder_, CONST)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, CONST); + result_ = result_ && constructorDesignation(builder_, level_ + 1); + result_ = result_ && arguments(builder_, level_ + 1); + exit_section_(builder_, marker_, CONST_OBJECT_EXPRESSION, result_); + return result_; } /* ********************************************************** */ @@ -1135,805 +1135,805 @@ public static boolean constObjectExpression(PsiBuilder b, int l) { // 'const' typeArguments? '[' elements? ']' | // 'const' typeArguments? '{' elements? '}' | // 'const' '(' expression ')' - public static boolean constantPattern(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, CONSTANT_PATTERN, ""); - r = consumeToken(b, NULL); - if (!r) r = consumeToken(b, TRUE); - if (!r) r = consumeToken(b, FALSE); - if (!r) r = constantPattern_3(b, l + 1); - if (!r) r = stringLiteralExpression(b, l + 1); - if (!r) r = symbolLiteralExpression(b, l + 1); - if (!r) r = staticMemberShorthandValue(b, l + 1); - if (!r) r = simpleQualifiedReferenceExpression(b, l + 1); - if (!r) r = constObjectExpression(b, l + 1); - if (!r) r = constantPattern_9(b, l + 1); - if (!r) r = constantPattern_10(b, l + 1); - if (!r) r = constantPattern_11(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean constantPattern(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CONSTANT_PATTERN, ""); + result_ = consumeToken(builder_, NULL); + if (!result_) result_ = consumeToken(builder_, TRUE); + if (!result_) result_ = consumeToken(builder_, FALSE); + if (!result_) result_ = constantPattern_3(builder_, level_ + 1); + if (!result_) result_ = stringLiteralExpression(builder_, level_ + 1); + if (!result_) result_ = symbolLiteralExpression(builder_, level_ + 1); + if (!result_) result_ = staticMemberShorthandValue(builder_, level_ + 1); + if (!result_) result_ = simpleQualifiedReferenceExpression(builder_, level_ + 1); + if (!result_) result_ = constObjectExpression(builder_, level_ + 1); + if (!result_) result_ = constantPattern_9(builder_, level_ + 1); + if (!result_) result_ = constantPattern_10(builder_, level_ + 1); + if (!result_) result_ = constantPattern_11(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // '-'? (NUMBER | HEX_NUMBER) - private static boolean constantPattern_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = constantPattern_3_0(b, l + 1); - r = r && constantPattern_3_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean constantPattern_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = constantPattern_3_0(builder_, level_ + 1); + result_ = result_ && constantPattern_3_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '-'? - private static boolean constantPattern_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_3_0")) return false; - consumeToken(b, MINUS); + private static boolean constantPattern_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_3_0")) return false; + consumeToken(builder_, MINUS); return true; } // NUMBER | HEX_NUMBER - private static boolean constantPattern_3_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_3_1")) return false; - boolean r; - r = consumeToken(b, NUMBER); - if (!r) r = consumeToken(b, HEX_NUMBER); - return r; + private static boolean constantPattern_3_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_3_1")) return false; + boolean result_; + result_ = consumeToken(builder_, NUMBER); + if (!result_) result_ = consumeToken(builder_, HEX_NUMBER); + return result_; } // 'const' typeArguments? '[' elements? ']' - private static boolean constantPattern_9(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_9")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, CONST); - r = r && constantPattern_9_1(b, l + 1); - r = r && consumeToken(b, LBRACKET); - r = r && constantPattern_9_3(b, l + 1); - r = r && consumeToken(b, RBRACKET); - exit_section_(b, m, null, r); - return r; + private static boolean constantPattern_9(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_9")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, CONST); + result_ = result_ && constantPattern_9_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, LBRACKET); + result_ = result_ && constantPattern_9_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RBRACKET); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeArguments? - private static boolean constantPattern_9_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_9_1")) return false; - typeArguments(b, l + 1); + private static boolean constantPattern_9_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_9_1")) return false; + typeArguments(builder_, level_ + 1); return true; } // elements? - private static boolean constantPattern_9_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_9_3")) return false; - elements(b, l + 1); + private static boolean constantPattern_9_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_9_3")) return false; + elements(builder_, level_ + 1); return true; } // 'const' typeArguments? '{' elements? '}' - private static boolean constantPattern_10(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_10")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, CONST); - r = r && constantPattern_10_1(b, l + 1); - r = r && consumeToken(b, LBRACE); - r = r && constantPattern_10_3(b, l + 1); - r = r && consumeToken(b, RBRACE); - exit_section_(b, m, null, r); - return r; + private static boolean constantPattern_10(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_10")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, CONST); + result_ = result_ && constantPattern_10_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, LBRACE); + result_ = result_ && constantPattern_10_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RBRACE); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeArguments? - private static boolean constantPattern_10_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_10_1")) return false; - typeArguments(b, l + 1); + private static boolean constantPattern_10_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_10_1")) return false; + typeArguments(builder_, level_ + 1); return true; } // elements? - private static boolean constantPattern_10_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_10_3")) return false; - elements(b, l + 1); + private static boolean constantPattern_10_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_10_3")) return false; + elements(builder_, level_ + 1); return true; } // 'const' '(' expression ')' - private static boolean constantPattern_11(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constantPattern_11")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, CONST, LPAREN); - r = r && expression(b, l + 1); - r = r && consumeToken(b, RPAREN); - exit_section_(b, m, null, r); - return r; + private static boolean constantPattern_11(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constantPattern_11")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, CONST, LPAREN); + result_ = result_ && expression(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RPAREN); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // simpleQualifiedReferenceExpression (typeArguments ('.' referenceExpression)?)? - static boolean constructorDesignation(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constructorDesignation")) return false; - boolean r; - Marker m = enter_section_(b); - r = simpleQualifiedReferenceExpression(b, l + 1); - r = r && constructorDesignation_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean constructorDesignation(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constructorDesignation")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = simpleQualifiedReferenceExpression(builder_, level_ + 1); + result_ = result_ && constructorDesignation_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // (typeArguments ('.' referenceExpression)?)? - private static boolean constructorDesignation_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constructorDesignation_1")) return false; - constructorDesignation_1_0(b, l + 1); + private static boolean constructorDesignation_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constructorDesignation_1")) return false; + constructorDesignation_1_0(builder_, level_ + 1); return true; } // typeArguments ('.' referenceExpression)? - private static boolean constructorDesignation_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constructorDesignation_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = typeArguments(b, l + 1); - r = r && constructorDesignation_1_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean constructorDesignation_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constructorDesignation_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = typeArguments(builder_, level_ + 1); + result_ = result_ && constructorDesignation_1_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ('.' referenceExpression)? - private static boolean constructorDesignation_1_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constructorDesignation_1_0_1")) return false; - constructorDesignation_1_0_1_0(b, l + 1); + private static boolean constructorDesignation_1_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constructorDesignation_1_0_1")) return false; + constructorDesignation_1_0_1_0(builder_, level_ + 1); return true; } // '.' referenceExpression - private static boolean constructorDesignation_1_0_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "constructorDesignation_1_0_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, DOT); - r = r && referenceExpression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean constructorDesignation_1_0_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "constructorDesignation_1_0_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, DOT); + result_ = result_ && referenceExpression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'continue' referenceExpression? ';' - public static boolean continueStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "continueStatement")) return false; - if (!nextTokenIs(b, CONTINUE)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, CONTINUE_STATEMENT, null); - r = consumeToken(b, CONTINUE); - p = r; // pin = 1 - r = r && report_error_(b, continueStatement_1(b, l + 1)); - r = p && consumeToken(b, SEMICOLON) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean continueStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "continueStatement")) return false; + if (!nextTokenIs(builder_, CONTINUE)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, CONTINUE_STATEMENT, null); + result_ = consumeToken(builder_, CONTINUE); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, continueStatement_1(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, SEMICOLON) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // referenceExpression? - private static boolean continueStatement_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "continueStatement_1")) return false; - referenceExpression(b, l + 1); + private static boolean continueStatement_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "continueStatement_1")) return false; + referenceExpression(builder_, level_ + 1); return true; } /* ********************************************************** */ // topLevelDefinition* - static boolean dartUnit(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "dartUnit")) return false; + static boolean dartUnit(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "dartUnit")) return false; while (true) { - int c = current_position_(b); - if (!topLevelDefinition(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "dartUnit", c)) break; + int pos_ = current_position_(builder_); + if (!topLevelDefinition(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "dartUnit", pos_)) break; } return true; } /* ********************************************************** */ // metadata* 'required'? finalConstVarOrTypeAndComponentName - static boolean declaredIdentifier(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "declaredIdentifier")) return false; - boolean r; - Marker m = enter_section_(b); - r = declaredIdentifier_0(b, l + 1); - r = r && declaredIdentifier_1(b, l + 1); - r = r && finalConstVarOrTypeAndComponentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean declaredIdentifier(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "declaredIdentifier")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = declaredIdentifier_0(builder_, level_ + 1); + result_ = result_ && declaredIdentifier_1(builder_, level_ + 1); + result_ = result_ && finalConstVarOrTypeAndComponentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean declaredIdentifier_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "declaredIdentifier_0")) return false; + private static boolean declaredIdentifier_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "declaredIdentifier_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "declaredIdentifier_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "declaredIdentifier_0", pos_)) break; } return true; } // 'required'? - private static boolean declaredIdentifier_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "declaredIdentifier_1")) return false; - consumeToken(b, REQUIRED); + private static boolean declaredIdentifier_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "declaredIdentifier_1")) return false; + consumeToken(builder_, REQUIRED); return true; } /* ********************************************************** */ // label* 'default' ':' statements - public static boolean defaultCase(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultCase")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, DEFAULT_CASE, ""); - r = defaultCase_0(b, l + 1); - r = r && consumeTokens(b, 1, DEFAULT, COLON); - p = r; // pin = 2 - r = r && statements(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean defaultCase(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultCase")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, DEFAULT_CASE, ""); + result_ = defaultCase_0(builder_, level_ + 1); + result_ = result_ && consumeTokens(builder_, 1, DEFAULT, COLON); + pinned_ = result_; // pin = 2 + result_ = result_ && statements(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // label* - private static boolean defaultCase_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultCase_0")) return false; + private static boolean defaultCase_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultCase_0")) return false; while (true) { - int c = current_position_(b); - if (!label(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "defaultCase_0", c)) break; + int pos_ = current_position_(builder_); + if (!label(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "defaultCase_0", pos_)) break; } return true; } /* ********************************************************** */ // normalFormalParameter (('=' | ':') expression)? - public static boolean defaultFormalNamedParameter(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultFormalNamedParameter")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, DEFAULT_FORMAL_NAMED_PARAMETER, ""); - r = normalFormalParameter(b, l + 1); - r = r && defaultFormalNamedParameter_1(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::default_formal_parameter_recover); - return r; + public static boolean defaultFormalNamedParameter(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultFormalNamedParameter")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, DEFAULT_FORMAL_NAMED_PARAMETER, ""); + result_ = normalFormalParameter(builder_, level_ + 1); + result_ = result_ && defaultFormalNamedParameter_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::default_formal_parameter_recover); + return result_; } // (('=' | ':') expression)? - private static boolean defaultFormalNamedParameter_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1")) return false; - defaultFormalNamedParameter_1_0(b, l + 1); + private static boolean defaultFormalNamedParameter_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultFormalNamedParameter_1")) return false; + defaultFormalNamedParameter_1_0(builder_, level_ + 1); return true; } // ('=' | ':') expression - private static boolean defaultFormalNamedParameter_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = defaultFormalNamedParameter_1_0_0(b, l + 1); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean defaultFormalNamedParameter_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultFormalNamedParameter_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = defaultFormalNamedParameter_1_0_0(builder_, level_ + 1); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '=' | ':' - private static boolean defaultFormalNamedParameter_1_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1_0_0")) return false; - boolean r; - r = consumeToken(b, EQ); - if (!r) r = consumeToken(b, COLON); - return r; + private static boolean defaultFormalNamedParameter_1_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "defaultFormalNamedParameter_1_0_0")) return false; + boolean result_; + result_ = consumeToken(builder_, EQ); + if (!result_) result_ = consumeToken(builder_, COLON); + return result_; } /* ********************************************************** */ // !(')' | ',' | ']' | '}') - static boolean default_formal_parameter_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "default_formal_parameter_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !default_formal_parameter_recover_0(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + static boolean default_formal_parameter_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "default_formal_parameter_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !default_formal_parameter_recover_0(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // ')' | ',' | ']' | '}' - private static boolean default_formal_parameter_recover_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "default_formal_parameter_recover_0")) return false; - boolean r; - r = consumeToken(b, RPAREN); - if (!r) r = consumeToken(b, COMMA); - if (!r) r = consumeToken(b, RBRACKET); - if (!r) r = consumeToken(b, RBRACE); - return r; + private static boolean default_formal_parameter_recover_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "default_formal_parameter_recover_0")) return false; + boolean result_; + result_ = consumeToken(builder_, RPAREN); + if (!result_) result_ = consumeToken(builder_, COMMA); + if (!result_) result_ = consumeToken(builder_, RBRACKET); + if (!result_) result_ = consumeToken(builder_, RBRACE); + return result_; } /* ********************************************************** */ // 'do' statement 'while' '(' expressionWithRecoverUntilParen ')' ';' - public static boolean doWhileStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "doWhileStatement")) return false; - if (!nextTokenIs(b, DO)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, DO_WHILE_STATEMENT, null); - r = consumeToken(b, DO); - p = r; // pin = 1 - r = r && report_error_(b, statement(b, l + 1)); - r = p && report_error_(b, consumeTokens(b, -1, WHILE, LPAREN)) && r; - r = p && report_error_(b, expressionWithRecoverUntilParen(b, l + 1)) && r; - r = p && report_error_(b, consumeTokens(b, -1, RPAREN, SEMICOLON)) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean doWhileStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "doWhileStatement")) return false; + if (!nextTokenIs(builder_, DO)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, DO_WHILE_STATEMENT, null); + result_ = consumeToken(builder_, DO); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, statement(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, consumeTokens(builder_, -1, WHILE, LPAREN)) && result_; + result_ = pinned_ && report_error_(builder_, expressionWithRecoverUntilParen(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, consumeTokens(builder_, -1, RPAREN, SEMICOLON)) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // <> ('.' <>)* - static boolean dottedName(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "dottedName")) return false; - boolean r; - Marker m = enter_section_(b); - r = nonStrictID(b, l + 1); - r = r && dottedName_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean dottedName(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "dottedName")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = nonStrictID(builder_, level_ + 1); + result_ = result_ && dottedName_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ('.' <>)* - private static boolean dottedName_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "dottedName_1")) return false; + private static boolean dottedName_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "dottedName_1")) return false; while (true) { - int c = current_position_(b); - if (!dottedName_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "dottedName_1", c)) break; + int pos_ = current_position_(builder_); + if (!dottedName_1_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "dottedName_1", pos_)) break; } return true; } // '.' <> - private static boolean dottedName_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "dottedName_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, DOT); - r = r && nonStrictID(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean dottedName_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "dottedName_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, DOT); + result_ = result_ && nonStrictID(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // spreadElement | ifElement | forElement | mapEntryOrExpression - public static boolean element(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "element")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, ELEMENT, ""); - r = spreadElement(b, l + 1); - if (!r) r = ifElement(b, l + 1); - if (!r) r = forElement(b, l + 1); - if (!r) r = mapEntryOrExpression(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean element(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "element")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ELEMENT, ""); + result_ = spreadElement(builder_, level_ + 1); + if (!result_) result_ = ifElement(builder_, level_ + 1); + if (!result_) result_ = forElement(builder_, level_ + 1); + if (!result_) result_ = mapEntryOrExpression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // element (','? element)* ','? - static boolean elements(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "elements")) return false; - boolean r; - Marker m = enter_section_(b); - r = element(b, l + 1); - r = r && elements_1(b, l + 1); - r = r && elements_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean elements(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "elements")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = element(builder_, level_ + 1); + result_ = result_ && elements_1(builder_, level_ + 1); + result_ = result_ && elements_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // (','? element)* - private static boolean elements_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "elements_1")) return false; + private static boolean elements_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "elements_1")) return false; while (true) { - int c = current_position_(b); - if (!elements_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "elements_1", c)) break; + int pos_ = current_position_(builder_); + if (!elements_1_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "elements_1", pos_)) break; } return true; } // ','? element - private static boolean elements_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "elements_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = elements_1_0_0(b, l + 1); - r = r && element(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean elements_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "elements_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = elements_1_0_0(builder_, level_ + 1); + result_ = result_ && element(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean elements_1_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "elements_1_0_0")) return false; - consumeToken(b, COMMA); + private static boolean elements_1_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "elements_1_0_0")) return false; + consumeToken(builder_, COMMA); return true; } // ','? - private static boolean elements_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "elements_2")) return false; - consumeToken(b, COMMA); + private static boolean elements_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "elements_2")) return false; + consumeToken(builder_, COMMA); return true; } /* ********************************************************** */ // metadata* 'augment'? componentName typeArguments? '.' componentName arguments | // metadata* 'augment'? componentName typeArguments? arguments? - public static boolean enumConstantDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, ENUM_CONSTANT_DECLARATION, ""); - r = enumConstantDeclaration_0(b, l + 1); - if (!r) r = enumConstantDeclaration_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean enumConstantDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ENUM_CONSTANT_DECLARATION, ""); + result_ = enumConstantDeclaration_0(builder_, level_ + 1); + if (!result_) result_ = enumConstantDeclaration_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* 'augment'? componentName typeArguments? '.' componentName arguments - private static boolean enumConstantDeclaration_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = enumConstantDeclaration_0_0(b, l + 1); - r = r && enumConstantDeclaration_0_1(b, l + 1); - r = r && componentName(b, l + 1); - r = r && enumConstantDeclaration_0_3(b, l + 1); - r = r && consumeToken(b, DOT); - r = r && componentName(b, l + 1); - r = r && arguments(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean enumConstantDeclaration_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = enumConstantDeclaration_0_0(builder_, level_ + 1); + result_ = result_ && enumConstantDeclaration_0_1(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && enumConstantDeclaration_0_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, DOT); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && arguments(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean enumConstantDeclaration_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_0_0")) return false; + private static boolean enumConstantDeclaration_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_0_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "enumConstantDeclaration_0_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "enumConstantDeclaration_0_0", pos_)) break; } return true; } // 'augment'? - private static boolean enumConstantDeclaration_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_0_1")) return false; - consumeToken(b, AUGMENT); + private static boolean enumConstantDeclaration_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_0_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeArguments? - private static boolean enumConstantDeclaration_0_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_0_3")) return false; - typeArguments(b, l + 1); + private static boolean enumConstantDeclaration_0_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_0_3")) return false; + typeArguments(builder_, level_ + 1); return true; } // metadata* 'augment'? componentName typeArguments? arguments? - private static boolean enumConstantDeclaration_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = enumConstantDeclaration_1_0(b, l + 1); - r = r && enumConstantDeclaration_1_1(b, l + 1); - r = r && componentName(b, l + 1); - r = r && enumConstantDeclaration_1_3(b, l + 1); - r = r && enumConstantDeclaration_1_4(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean enumConstantDeclaration_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = enumConstantDeclaration_1_0(builder_, level_ + 1); + result_ = result_ && enumConstantDeclaration_1_1(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && enumConstantDeclaration_1_3(builder_, level_ + 1); + result_ = result_ && enumConstantDeclaration_1_4(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean enumConstantDeclaration_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_1_0")) return false; + private static boolean enumConstantDeclaration_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_1_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "enumConstantDeclaration_1_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "enumConstantDeclaration_1_0", pos_)) break; } return true; } // 'augment'? - private static boolean enumConstantDeclaration_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_1_1")) return false; - consumeToken(b, AUGMENT); + private static boolean enumConstantDeclaration_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_1_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeArguments? - private static boolean enumConstantDeclaration_1_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_1_3")) return false; - typeArguments(b, l + 1); + private static boolean enumConstantDeclaration_1_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_1_3")) return false; + typeArguments(builder_, level_ + 1); return true; } // arguments? - private static boolean enumConstantDeclaration_1_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumConstantDeclaration_1_4")) return false; - arguments(b, l + 1); + private static boolean enumConstantDeclaration_1_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumConstantDeclaration_1_4")) return false; + arguments(builder_, level_ + 1); return true; } /* ********************************************************** */ // metadata* 'augment'? 'enum' componentName typeParameters? mixins? interfaces? '{' enumConstantDeclaration? (',' enumConstantDeclaration)* ','? ';'? classMembers '}' - public static boolean enumDefinition(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, ENUM)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, ENUM_DEFINITION, ""); - r = enumDefinition_0(b, l + 1); - r = r && enumDefinition_1(b, l + 1); - r = r && consumeToken(b, ENUM); - r = r && componentName(b, l + 1); - p = r; // pin = 4 - r = r && report_error_(b, enumDefinition_4(b, l + 1)); - r = p && report_error_(b, enumDefinition_5(b, l + 1)) && r; - r = p && report_error_(b, enumDefinition_6(b, l + 1)) && r; - r = p && report_error_(b, consumeToken(b, LBRACE)) && r; - r = p && report_error_(b, enumDefinition_8(b, l + 1)) && r; - r = p && report_error_(b, enumDefinition_9(b, l + 1)) && r; - r = p && report_error_(b, enumDefinition_10(b, l + 1)) && r; - r = p && report_error_(b, enumDefinition_11(b, l + 1)) && r; - r = p && report_error_(b, classMembers(b, l + 1)) && r; - r = p && consumeToken(b, RBRACE) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean enumDefinition(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, ENUM)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, ENUM_DEFINITION, ""); + result_ = enumDefinition_0(builder_, level_ + 1); + result_ = result_ && enumDefinition_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, ENUM); + result_ = result_ && componentName(builder_, level_ + 1); + pinned_ = result_; // pin = 4 + result_ = result_ && report_error_(builder_, enumDefinition_4(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, enumDefinition_5(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, enumDefinition_6(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, consumeToken(builder_, LBRACE)) && result_; + result_ = pinned_ && report_error_(builder_, enumDefinition_8(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, enumDefinition_9(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, enumDefinition_10(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, enumDefinition_11(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, classMembers(builder_, level_ + 1)) && result_; + result_ = pinned_ && consumeToken(builder_, RBRACE) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean enumDefinition_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_0")) return false; + private static boolean enumDefinition_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "enumDefinition_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "enumDefinition_0", pos_)) break; } return true; } // 'augment'? - private static boolean enumDefinition_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_1")) return false; - consumeToken(b, AUGMENT); + private static boolean enumDefinition_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeParameters? - private static boolean enumDefinition_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_4")) return false; - typeParameters(b, l + 1); + private static boolean enumDefinition_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_4")) return false; + typeParameters(builder_, level_ + 1); return true; } // mixins? - private static boolean enumDefinition_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_5")) return false; - mixins(b, l + 1); + private static boolean enumDefinition_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_5")) return false; + mixins(builder_, level_ + 1); return true; } // interfaces? - private static boolean enumDefinition_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_6")) return false; - interfaces(b, l + 1); + private static boolean enumDefinition_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_6")) return false; + interfaces(builder_, level_ + 1); return true; } // enumConstantDeclaration? - private static boolean enumDefinition_8(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_8")) return false; - enumConstantDeclaration(b, l + 1); + private static boolean enumDefinition_8(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_8")) return false; + enumConstantDeclaration(builder_, level_ + 1); return true; } // (',' enumConstantDeclaration)* - private static boolean enumDefinition_9(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_9")) return false; + private static boolean enumDefinition_9(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_9")) return false; while (true) { - int c = current_position_(b); - if (!enumDefinition_9_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "enumDefinition_9", c)) break; + int pos_ = current_position_(builder_); + if (!enumDefinition_9_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "enumDefinition_9", pos_)) break; } return true; } // ',' enumConstantDeclaration - private static boolean enumDefinition_9_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_9_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && enumConstantDeclaration(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean enumDefinition_9_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_9_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && enumConstantDeclaration(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean enumDefinition_10(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_10")) return false; - consumeToken(b, COMMA); + private static boolean enumDefinition_10(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_10")) return false; + consumeToken(builder_, COMMA); return true; } // ';'? - private static boolean enumDefinition_11(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "enumDefinition_11")) return false; - consumeToken(b, SEMICOLON); + private static boolean enumDefinition_11(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "enumDefinition_11")) return false; + consumeToken(builder_, SEMICOLON); return true; } /* ********************************************************** */ // '==' | '!=' - public static boolean equalityOperator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "equalityOperator")) return false; - if (!nextTokenIs(b, "", EQ_EQ, NEQ)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, EQUALITY_OPERATOR, ""); - r = consumeToken(b, EQ_EQ); - if (!r) r = consumeToken(b, NEQ); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean equalityOperator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "equalityOperator")) return false; + if (!nextTokenIs(builder_, "", EQ_EQ, NEQ)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, EQUALITY_OPERATOR, ""); + result_ = consumeToken(builder_, EQ_EQ); + if (!result_) result_ = consumeToken(builder_, NEQ); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // metadata* 'export' uriElement importConfig* combinator* ';' - public static boolean exportStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "exportStatement")) return false; - if (!nextTokenIs(b, "", AT, EXPORT)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, EXPORT_STATEMENT, ""); - r = exportStatement_0(b, l + 1); - r = r && consumeToken(b, EXPORT); - r = r && uriElement(b, l + 1); - p = r; // pin = 3 - r = r && report_error_(b, exportStatement_3(b, l + 1)); - r = p && report_error_(b, exportStatement_4(b, l + 1)) && r; - r = p && consumeToken(b, SEMICOLON) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean exportStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "exportStatement")) return false; + if (!nextTokenIs(builder_, "", AT, EXPORT)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, EXPORT_STATEMENT, ""); + result_ = exportStatement_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EXPORT); + result_ = result_ && uriElement(builder_, level_ + 1); + pinned_ = result_; // pin = 3 + result_ = result_ && report_error_(builder_, exportStatement_3(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, exportStatement_4(builder_, level_ + 1)) && result_; + result_ = pinned_ && consumeToken(builder_, SEMICOLON) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean exportStatement_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "exportStatement_0")) return false; + private static boolean exportStatement_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "exportStatement_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "exportStatement_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "exportStatement_0", pos_)) break; } return true; } // importConfig* - private static boolean exportStatement_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "exportStatement_3")) return false; + private static boolean exportStatement_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "exportStatement_3")) return false; while (true) { - int c = current_position_(b); - if (!importConfig(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "exportStatement_3", c)) break; + int pos_ = current_position_(builder_); + if (!importConfig(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "exportStatement_3", pos_)) break; } return true; } // combinator* - private static boolean exportStatement_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "exportStatement_4")) return false; + private static boolean exportStatement_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "exportStatement_4")) return false; while (true) { - int c = current_position_(b); - if (!combinator(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "exportStatement_4", c)) break; + int pos_ = current_position_(builder_); + if (!combinator(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "exportStatement_4", pos_)) break; } return true; } /* ********************************************************** */ // assignExpressionWrapper - public static boolean expression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expression")) return false; - boolean r; - Marker m = enter_section_(b, l, _COLLAPSE_, EXPRESSION, ""); - r = assignExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::expression_recover); - return r; + public static boolean expression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expression")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, EXPRESSION, ""); + result_ = assignExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::expression_recover); + return result_; } /* ********************************************************** */ // 'case' expression ':' - static boolean expressionCase(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionCase")) return false; - if (!nextTokenIs(b, CASE)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = consumeToken(b, CASE); - p = r; // pin = 1 - r = r && report_error_(b, expression(b, l + 1)); - r = p && consumeToken(b, COLON) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean expressionCase(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionCase")) return false; + if (!nextTokenIs(builder_, CASE)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = consumeToken(builder_, CASE); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, expression(builder_, level_ + 1)); + result_ = pinned_ && consumeToken(builder_, COLON) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // expression | statement - static boolean expressionInParentheses(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionInParentheses")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = expression(b, l + 1); - if (!r) r = statement(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::parenthesesRecovery); - return r; + static boolean expressionInParentheses(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionInParentheses")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = expression(builder_, level_ + 1); + if (!result_) result_ = statement(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::parenthesesRecovery); + return result_; } /* ********************************************************** */ // expression (','? expression)* - public static boolean expressionList(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionList")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, EXPRESSION_LIST, ""); - r = expression(b, l + 1); - r = r && expressionList_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean expressionList(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionList")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, EXPRESSION_LIST, ""); + result_ = expression(builder_, level_ + 1); + result_ = result_ && expressionList_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // (','? expression)* - private static boolean expressionList_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionList_1")) return false; + private static boolean expressionList_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionList_1")) return false; while (true) { - int c = current_position_(b); - if (!expressionList_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "expressionList_1", c)) break; + int pos_ = current_position_(builder_); + if (!expressionList_1_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "expressionList_1", pos_)) break; } return true; } // ','? expression - private static boolean expressionList_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionList_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = expressionList_1_0_0(b, l + 1); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean expressionList_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionList_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = expressionList_1_0_0(builder_, level_ + 1); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean expressionList_1_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionList_1_0_0")) return false; - consumeToken(b, COMMA); + private static boolean expressionList_1_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionList_1_0_0")) return false; + consumeToken(builder_, COMMA); return true; } /* ********************************************************** */ // expression - static boolean expressionWithRecoverUntilParen(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionWithRecoverUntilParen")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = expression(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::not_paren_recover); - return r; + static boolean expressionWithRecoverUntilParen(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionWithRecoverUntilParen")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = expression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::not_paren_recover); + return result_; } /* ********************************************************** */ // expression - static boolean expressionWithRecoverUntilParenOrComma(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expressionWithRecoverUntilParenOrComma")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = expression(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::not_paren_or_comma_recover); - return r; + static boolean expressionWithRecoverUntilParenOrComma(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expressionWithRecoverUntilParenOrComma")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = expression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::not_paren_or_comma_recover); + return result_; } /* ********************************************************** */ @@ -1951,13 +1951,13 @@ static boolean expressionWithRecoverUntilParenOrComma(PsiBuilder b, int l) { // 'yield' | '{' | '|' | '|=' | '||' | '||=' | '}' | '~' | '~/' | '~/=' | CLOSING_QUOTE | FALSE | HEX_NUMBER | // LONG_TEMPLATE_ENTRY_END | LONG_TEMPLATE_ENTRY_START | NULL | NUMBER | OPEN_QUOTE | RAW_SINGLE_QUOTED_STRING | // RAW_TRIPLE_QUOTED_STRING | REGULAR_STRING_PART | SHORT_TEMPLATE_ENTRY_START | TRUE) - static boolean expression_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expression_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !expression_recover_0(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + static boolean expression_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expression_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !expression_recover_0(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // <> | @@ -1974,535 +1974,535 @@ static boolean expression_recover(PsiBuilder b, int l) { // 'yield' | '{' | '|' | '|=' | '||' | '||=' | '}' | '~' | '~/' | '~/=' | CLOSING_QUOTE | FALSE | HEX_NUMBER | // LONG_TEMPLATE_ENTRY_END | LONG_TEMPLATE_ENTRY_START | NULL | NUMBER | OPEN_QUOTE | RAW_SINGLE_QUOTED_STRING | // RAW_TRIPLE_QUOTED_STRING | REGULAR_STRING_PART | SHORT_TEMPLATE_ENTRY_START | TRUE - private static boolean expression_recover_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expression_recover_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = nonStrictID(b, l + 1); - if (!r) r = consumeToken(b, ASYNC); - if (!r) r = consumeToken(b, SYNC); - if (!r) r = expression_recover_0_3(b, l + 1); - if (!r) r = gtGt(b, l + 1); - if (!r) r = gtGtEq(b, l + 1); - if (!r) r = gtGtGt(b, l + 1); - if (!r) r = gtGtGtEq(b, l + 1); - if (!r) r = consumeToken(b, NOT); - if (!r) r = consumeToken(b, NEQ); - if (!r) r = consumeToken(b, HASH); - if (!r) r = consumeToken(b, REM); - if (!r) r = consumeToken(b, REM_EQ); - if (!r) r = consumeToken(b, AND_AND); - if (!r) r = consumeToken(b, AND_AND_EQ); - if (!r) r = consumeToken(b, AND); - if (!r) r = consumeToken(b, AND_EQ); - if (!r) r = consumeToken(b, LPAREN); - if (!r) r = consumeToken(b, RPAREN); - if (!r) r = consumeToken(b, MUL); - if (!r) r = consumeToken(b, MUL_EQ); - if (!r) r = consumeToken(b, PLUS); - if (!r) r = consumeToken(b, PLUS_PLUS); - if (!r) r = consumeToken(b, PLUS_EQ); - if (!r) r = consumeToken(b, COMMA); - if (!r) r = consumeToken(b, MINUS); - if (!r) r = consumeToken(b, MINUS_MINUS); - if (!r) r = consumeToken(b, MINUS_EQ); - if (!r) r = consumeToken(b, DOT); - if (!r) r = consumeToken(b, DOT_DOT); - if (!r) r = consumeToken(b, DOT_DOT_DOT); - if (!r) r = consumeToken(b, DOT_DOT_DOT_QUEST); - if (!r) r = consumeToken(b, DIV); - if (!r) r = consumeToken(b, DIV_EQ); - if (!r) r = consumeToken(b, COLON); - if (!r) r = consumeToken(b, SEMICOLON); - if (!r) r = consumeToken(b, LT); - if (!r) r = consumeToken(b, LT_LT); - if (!r) r = consumeToken(b, LT_LT_EQ); - if (!r) r = consumeToken(b, LT_EQ); - if (!r) r = consumeToken(b, EQ); - if (!r) r = consumeToken(b, EQ_EQ); - if (!r) r = consumeToken(b, EXPRESSION_BODY_DEF); - if (!r) r = consumeToken(b, GT); - if (!r) r = consumeToken(b, QUEST); - if (!r) r = consumeToken(b, QUEST_DOT); - if (!r) r = consumeToken(b, QUEST_DOT_DOT); - if (!r) r = consumeToken(b, QUEST_QUEST); - if (!r) r = consumeToken(b, QUEST_QUEST_EQ); - if (!r) r = consumeToken(b, AT); - if (!r) r = consumeToken(b, LBRACKET); - if (!r) r = consumeToken(b, RBRACKET); - if (!r) r = consumeToken(b, XOR); - if (!r) r = consumeToken(b, XOR_EQ); - if (!r) r = consumeToken(b, ABSTRACT); - if (!r) r = consumeToken(b, AS); - if (!r) r = consumeToken(b, ASSERT); - if (!r) r = consumeToken(b, AWAIT); - if (!r) r = consumeToken(b, BASE); - if (!r) r = consumeToken(b, BREAK); - if (!r) r = consumeToken(b, CASE); - if (!r) r = consumeToken(b, CATCH); - if (!r) r = consumeToken(b, CLASS); - if (!r) r = consumeToken(b, CONST); - if (!r) r = consumeToken(b, CONTINUE); - if (!r) r = consumeToken(b, COVARIANT); - if (!r) r = consumeToken(b, DEFAULT); - if (!r) r = consumeToken(b, DEFERRED); - if (!r) r = consumeToken(b, DO); - if (!r) r = consumeToken(b, ELSE); - if (!r) r = consumeToken(b, ENUM); - if (!r) r = consumeToken(b, EXPORT); - if (!r) r = consumeToken(b, EXTENSION); - if (!r) r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, FACTORY); - if (!r) r = consumeToken(b, FINAL); - if (!r) r = consumeToken(b, FINALLY); - if (!r) r = consumeToken(b, FOR); - if (!r) r = consumeToken(b, GET); - if (!r) r = consumeToken(b, HIDE); - if (!r) r = consumeToken(b, IF); - if (!r) r = consumeToken(b, IMPORT); - if (!r) r = consumeToken(b, INTERFACE); - if (!r) r = consumeToken(b, IS); - if (!r) r = consumeToken(b, LATE); - if (!r) r = consumeToken(b, LIBRARY); - if (!r) r = consumeToken(b, MIXIN); - if (!r) r = consumeToken(b, NATIVE); - if (!r) r = consumeToken(b, NEW); - if (!r) r = consumeToken(b, ON); - if (!r) r = consumeToken(b, PART); - if (!r) r = consumeToken(b, RETHROW); - if (!r) r = consumeToken(b, RETURN); - if (!r) r = consumeToken(b, SEALED); - if (!r) r = consumeToken(b, SET); - if (!r) r = consumeToken(b, SHOW); - if (!r) r = consumeToken(b, STATIC); - if (!r) r = consumeToken(b, SUPER); - if (!r) r = consumeToken(b, SWITCH); - if (!r) r = consumeToken(b, THIS); - if (!r) r = consumeToken(b, THROW); - if (!r) r = consumeToken(b, TRY); - if (!r) r = consumeToken(b, TYPEDEF); - if (!r) r = consumeToken(b, VAR); - if (!r) r = consumeToken(b, VOID); - if (!r) r = consumeToken(b, WHEN); - if (!r) r = consumeToken(b, WHILE); - if (!r) r = consumeToken(b, YIELD); - if (!r) r = consumeToken(b, LBRACE); - if (!r) r = consumeToken(b, OR); - if (!r) r = consumeToken(b, OR_EQ); - if (!r) r = consumeToken(b, OR_OR); - if (!r) r = consumeToken(b, OR_OR_EQ); - if (!r) r = consumeToken(b, RBRACE); - if (!r) r = consumeToken(b, BIN_NOT); - if (!r) r = consumeToken(b, INT_DIV); - if (!r) r = consumeToken(b, INT_DIV_EQ); - if (!r) r = consumeToken(b, CLOSING_QUOTE); - if (!r) r = consumeToken(b, FALSE); - if (!r) r = consumeToken(b, HEX_NUMBER); - if (!r) r = consumeToken(b, LONG_TEMPLATE_ENTRY_END); - if (!r) r = consumeToken(b, LONG_TEMPLATE_ENTRY_START); - if (!r) r = consumeToken(b, NULL); - if (!r) r = consumeToken(b, NUMBER); - if (!r) r = consumeToken(b, OPEN_QUOTE); - if (!r) r = consumeToken(b, RAW_SINGLE_QUOTED_STRING); - if (!r) r = consumeToken(b, RAW_TRIPLE_QUOTED_STRING); - if (!r) r = consumeToken(b, REGULAR_STRING_PART); - if (!r) r = consumeToken(b, SHORT_TEMPLATE_ENTRY_START); - if (!r) r = consumeToken(b, TRUE); - exit_section_(b, m, null, r); - return r; + private static boolean expression_recover_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expression_recover_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = nonStrictID(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, ASYNC); + if (!result_) result_ = consumeToken(builder_, SYNC); + if (!result_) result_ = expression_recover_0_3(builder_, level_ + 1); + if (!result_) result_ = gtGt(builder_, level_ + 1); + if (!result_) result_ = gtGtEq(builder_, level_ + 1); + if (!result_) result_ = gtGtGt(builder_, level_ + 1); + if (!result_) result_ = gtGtGtEq(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, NOT); + if (!result_) result_ = consumeToken(builder_, NEQ); + if (!result_) result_ = consumeToken(builder_, HASH); + if (!result_) result_ = consumeToken(builder_, REM); + if (!result_) result_ = consumeToken(builder_, REM_EQ); + if (!result_) result_ = consumeToken(builder_, AND_AND); + if (!result_) result_ = consumeToken(builder_, AND_AND_EQ); + if (!result_) result_ = consumeToken(builder_, AND); + if (!result_) result_ = consumeToken(builder_, AND_EQ); + if (!result_) result_ = consumeToken(builder_, LPAREN); + if (!result_) result_ = consumeToken(builder_, RPAREN); + if (!result_) result_ = consumeToken(builder_, MUL); + if (!result_) result_ = consumeToken(builder_, MUL_EQ); + if (!result_) result_ = consumeToken(builder_, PLUS); + if (!result_) result_ = consumeToken(builder_, PLUS_PLUS); + if (!result_) result_ = consumeToken(builder_, PLUS_EQ); + if (!result_) result_ = consumeToken(builder_, COMMA); + if (!result_) result_ = consumeToken(builder_, MINUS); + if (!result_) result_ = consumeToken(builder_, MINUS_MINUS); + if (!result_) result_ = consumeToken(builder_, MINUS_EQ); + if (!result_) result_ = consumeToken(builder_, DOT); + if (!result_) result_ = consumeToken(builder_, DOT_DOT); + if (!result_) result_ = consumeToken(builder_, DOT_DOT_DOT); + if (!result_) result_ = consumeToken(builder_, DOT_DOT_DOT_QUEST); + if (!result_) result_ = consumeToken(builder_, DIV); + if (!result_) result_ = consumeToken(builder_, DIV_EQ); + if (!result_) result_ = consumeToken(builder_, COLON); + if (!result_) result_ = consumeToken(builder_, SEMICOLON); + if (!result_) result_ = consumeToken(builder_, LT); + if (!result_) result_ = consumeToken(builder_, LT_LT); + if (!result_) result_ = consumeToken(builder_, LT_LT_EQ); + if (!result_) result_ = consumeToken(builder_, LT_EQ); + if (!result_) result_ = consumeToken(builder_, EQ); + if (!result_) result_ = consumeToken(builder_, EQ_EQ); + if (!result_) result_ = consumeToken(builder_, EXPRESSION_BODY_DEF); + if (!result_) result_ = consumeToken(builder_, GT); + if (!result_) result_ = consumeToken(builder_, QUEST); + if (!result_) result_ = consumeToken(builder_, QUEST_DOT); + if (!result_) result_ = consumeToken(builder_, QUEST_DOT_DOT); + if (!result_) result_ = consumeToken(builder_, QUEST_QUEST); + if (!result_) result_ = consumeToken(builder_, QUEST_QUEST_EQ); + if (!result_) result_ = consumeToken(builder_, AT); + if (!result_) result_ = consumeToken(builder_, LBRACKET); + if (!result_) result_ = consumeToken(builder_, RBRACKET); + if (!result_) result_ = consumeToken(builder_, XOR); + if (!result_) result_ = consumeToken(builder_, XOR_EQ); + if (!result_) result_ = consumeToken(builder_, ABSTRACT); + if (!result_) result_ = consumeToken(builder_, AS); + if (!result_) result_ = consumeToken(builder_, ASSERT); + if (!result_) result_ = consumeToken(builder_, AWAIT); + if (!result_) result_ = consumeToken(builder_, BASE); + if (!result_) result_ = consumeToken(builder_, BREAK); + if (!result_) result_ = consumeToken(builder_, CASE); + if (!result_) result_ = consumeToken(builder_, CATCH); + if (!result_) result_ = consumeToken(builder_, CLASS); + if (!result_) result_ = consumeToken(builder_, CONST); + if (!result_) result_ = consumeToken(builder_, CONTINUE); + if (!result_) result_ = consumeToken(builder_, COVARIANT); + if (!result_) result_ = consumeToken(builder_, DEFAULT); + if (!result_) result_ = consumeToken(builder_, DEFERRED); + if (!result_) result_ = consumeToken(builder_, DO); + if (!result_) result_ = consumeToken(builder_, ELSE); + if (!result_) result_ = consumeToken(builder_, ENUM); + if (!result_) result_ = consumeToken(builder_, EXPORT); + if (!result_) result_ = consumeToken(builder_, EXTENSION); + if (!result_) result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, FACTORY); + if (!result_) result_ = consumeToken(builder_, FINAL); + if (!result_) result_ = consumeToken(builder_, FINALLY); + if (!result_) result_ = consumeToken(builder_, FOR); + if (!result_) result_ = consumeToken(builder_, GET); + if (!result_) result_ = consumeToken(builder_, HIDE); + if (!result_) result_ = consumeToken(builder_, IF); + if (!result_) result_ = consumeToken(builder_, IMPORT); + if (!result_) result_ = consumeToken(builder_, INTERFACE); + if (!result_) result_ = consumeToken(builder_, IS); + if (!result_) result_ = consumeToken(builder_, LATE); + if (!result_) result_ = consumeToken(builder_, LIBRARY); + if (!result_) result_ = consumeToken(builder_, MIXIN); + if (!result_) result_ = consumeToken(builder_, NATIVE); + if (!result_) result_ = consumeToken(builder_, NEW); + if (!result_) result_ = consumeToken(builder_, ON); + if (!result_) result_ = consumeToken(builder_, PART); + if (!result_) result_ = consumeToken(builder_, RETHROW); + if (!result_) result_ = consumeToken(builder_, RETURN); + if (!result_) result_ = consumeToken(builder_, SEALED); + if (!result_) result_ = consumeToken(builder_, SET); + if (!result_) result_ = consumeToken(builder_, SHOW); + if (!result_) result_ = consumeToken(builder_, STATIC); + if (!result_) result_ = consumeToken(builder_, SUPER); + if (!result_) result_ = consumeToken(builder_, SWITCH); + if (!result_) result_ = consumeToken(builder_, THIS); + if (!result_) result_ = consumeToken(builder_, THROW); + if (!result_) result_ = consumeToken(builder_, TRY); + if (!result_) result_ = consumeToken(builder_, TYPEDEF); + if (!result_) result_ = consumeToken(builder_, VAR); + if (!result_) result_ = consumeToken(builder_, VOID); + if (!result_) result_ = consumeToken(builder_, WHEN); + if (!result_) result_ = consumeToken(builder_, WHILE); + if (!result_) result_ = consumeToken(builder_, YIELD); + if (!result_) result_ = consumeToken(builder_, LBRACE); + if (!result_) result_ = consumeToken(builder_, OR); + if (!result_) result_ = consumeToken(builder_, OR_EQ); + if (!result_) result_ = consumeToken(builder_, OR_OR); + if (!result_) result_ = consumeToken(builder_, OR_OR_EQ); + if (!result_) result_ = consumeToken(builder_, RBRACE); + if (!result_) result_ = consumeToken(builder_, BIN_NOT); + if (!result_) result_ = consumeToken(builder_, INT_DIV); + if (!result_) result_ = consumeToken(builder_, INT_DIV_EQ); + if (!result_) result_ = consumeToken(builder_, CLOSING_QUOTE); + if (!result_) result_ = consumeToken(builder_, FALSE); + if (!result_) result_ = consumeToken(builder_, HEX_NUMBER); + if (!result_) result_ = consumeToken(builder_, LONG_TEMPLATE_ENTRY_END); + if (!result_) result_ = consumeToken(builder_, LONG_TEMPLATE_ENTRY_START); + if (!result_) result_ = consumeToken(builder_, NULL); + if (!result_) result_ = consumeToken(builder_, NUMBER); + if (!result_) result_ = consumeToken(builder_, OPEN_QUOTE); + if (!result_) result_ = consumeToken(builder_, RAW_SINGLE_QUOTED_STRING); + if (!result_) result_ = consumeToken(builder_, RAW_TRIPLE_QUOTED_STRING); + if (!result_) result_ = consumeToken(builder_, REGULAR_STRING_PART); + if (!result_) result_ = consumeToken(builder_, SHORT_TEMPLATE_ENTRY_START); + if (!result_) result_ = consumeToken(builder_, TRUE); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'operator' // <> - private static boolean expression_recover_0_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "expression_recover_0_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, OPERATOR); - r = r && gtEq(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean expression_recover_0_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "expression_recover_0_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, OPERATOR); + result_ = result_ && gtEq(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // metadata* 'augment'? 'extension' typeParameters? 'on' type '?'? classBody | // metadata* 'augment'? 'extension' <> typeParameters? 'on' type '?'? classBody - public static boolean extensionDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, EXTENSION)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, EXTENSION_DECLARATION, ""); - r = extensionDeclaration_0(b, l + 1); - if (!r) r = extensionDeclaration_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean extensionDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, EXTENSION)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, EXTENSION_DECLARATION, ""); + result_ = extensionDeclaration_0(builder_, level_ + 1); + if (!result_) result_ = extensionDeclaration_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* 'augment'? 'extension' typeParameters? 'on' type '?'? classBody - private static boolean extensionDeclaration_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = extensionDeclaration_0_0(b, l + 1); - r = r && extensionDeclaration_0_1(b, l + 1); - r = r && consumeToken(b, EXTENSION); - r = r && extensionDeclaration_0_3(b, l + 1); - r = r && consumeToken(b, ON); - r = r && type(b, l + 1); - r = r && extensionDeclaration_0_6(b, l + 1); - r = r && classBody(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean extensionDeclaration_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = extensionDeclaration_0_0(builder_, level_ + 1); + result_ = result_ && extensionDeclaration_0_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EXTENSION); + result_ = result_ && extensionDeclaration_0_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, ON); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && extensionDeclaration_0_6(builder_, level_ + 1); + result_ = result_ && classBody(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean extensionDeclaration_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_0_0")) return false; + private static boolean extensionDeclaration_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_0_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "extensionDeclaration_0_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "extensionDeclaration_0_0", pos_)) break; } return true; } // 'augment'? - private static boolean extensionDeclaration_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_0_1")) return false; - consumeToken(b, AUGMENT); + private static boolean extensionDeclaration_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_0_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeParameters? - private static boolean extensionDeclaration_0_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_0_3")) return false; - typeParameters(b, l + 1); + private static boolean extensionDeclaration_0_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_0_3")) return false; + typeParameters(builder_, level_ + 1); return true; } // '?'? - private static boolean extensionDeclaration_0_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_0_6")) return false; - consumeToken(b, QUEST); + private static boolean extensionDeclaration_0_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_0_6")) return false; + consumeToken(builder_, QUEST); return true; } // metadata* 'augment'? 'extension' <> typeParameters? 'on' type '?'? classBody - private static boolean extensionDeclaration_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = extensionDeclaration_1_0(b, l + 1); - r = r && extensionDeclaration_1_1(b, l + 1); - r = r && consumeToken(b, EXTENSION); - r = r && nonStrictID(b, l + 1); - r = r && extensionDeclaration_1_4(b, l + 1); - r = r && consumeToken(b, ON); - r = r && type(b, l + 1); - r = r && extensionDeclaration_1_7(b, l + 1); - r = r && classBody(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean extensionDeclaration_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = extensionDeclaration_1_0(builder_, level_ + 1); + result_ = result_ && extensionDeclaration_1_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EXTENSION); + result_ = result_ && nonStrictID(builder_, level_ + 1); + result_ = result_ && extensionDeclaration_1_4(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, ON); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && extensionDeclaration_1_7(builder_, level_ + 1); + result_ = result_ && classBody(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean extensionDeclaration_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_1_0")) return false; + private static boolean extensionDeclaration_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_1_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "extensionDeclaration_1_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "extensionDeclaration_1_0", pos_)) break; } return true; } // 'augment'? - private static boolean extensionDeclaration_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_1_1")) return false; - consumeToken(b, AUGMENT); + private static boolean extensionDeclaration_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_1_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeParameters? - private static boolean extensionDeclaration_1_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_1_4")) return false; - typeParameters(b, l + 1); + private static boolean extensionDeclaration_1_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_1_4")) return false; + typeParameters(builder_, level_ + 1); return true; } // '?'? - private static boolean extensionDeclaration_1_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionDeclaration_1_7")) return false; - consumeToken(b, QUEST); + private static boolean extensionDeclaration_1_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionDeclaration_1_7")) return false; + consumeToken(builder_, QUEST); return true; } /* ********************************************************** */ // metadata* 'augment'? 'extension' <> 'const'? componentName typeParameters? representationDeclaration interfaces? classBody - public static boolean extensionTypeDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, EXTENSION)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, EXTENSION_TYPE_DECLARATION, ""); - r = extensionTypeDeclaration_0(b, l + 1); - r = r && extensionTypeDeclaration_1(b, l + 1); - r = r && consumeToken(b, EXTENSION); - r = r && typeForExtensionType(b, l + 1); - r = r && extensionTypeDeclaration_4(b, l + 1); - r = r && componentName(b, l + 1); - p = r; // pin = 6 - r = r && report_error_(b, extensionTypeDeclaration_6(b, l + 1)); - r = p && report_error_(b, representationDeclaration(b, l + 1)) && r; - r = p && report_error_(b, extensionTypeDeclaration_8(b, l + 1)) && r; - r = p && classBody(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean extensionTypeDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, EXTENSION)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, EXTENSION_TYPE_DECLARATION, ""); + result_ = extensionTypeDeclaration_0(builder_, level_ + 1); + result_ = result_ && extensionTypeDeclaration_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EXTENSION); + result_ = result_ && typeForExtensionType(builder_, level_ + 1); + result_ = result_ && extensionTypeDeclaration_4(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + pinned_ = result_; // pin = 6 + result_ = result_ && report_error_(builder_, extensionTypeDeclaration_6(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, representationDeclaration(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, extensionTypeDeclaration_8(builder_, level_ + 1)) && result_; + result_ = pinned_ && classBody(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean extensionTypeDeclaration_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration_0")) return false; + private static boolean extensionTypeDeclaration_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "extensionTypeDeclaration_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "extensionTypeDeclaration_0", pos_)) break; } return true; } // 'augment'? - private static boolean extensionTypeDeclaration_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration_1")) return false; - consumeToken(b, AUGMENT); + private static boolean extensionTypeDeclaration_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // 'const'? - private static boolean extensionTypeDeclaration_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration_4")) return false; - consumeToken(b, CONST); + private static boolean extensionTypeDeclaration_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration_4")) return false; + consumeToken(builder_, CONST); return true; } // typeParameters? - private static boolean extensionTypeDeclaration_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration_6")) return false; - typeParameters(b, l + 1); + private static boolean extensionTypeDeclaration_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration_6")) return false; + typeParameters(builder_, level_ + 1); return true; } // interfaces? - private static boolean extensionTypeDeclaration_8(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "extensionTypeDeclaration_8")) return false; - interfaces(b, l + 1); + private static boolean extensionTypeDeclaration_8(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "extensionTypeDeclaration_8")) return false; + interfaces(builder_, level_ + 1); return true; } /* ********************************************************** */ // metadata* 'augment'? ('external' | 'const')* 'factory' componentName ('.' componentName)? formalParameterList factoryTail? - public static boolean factoryConstructorDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, + public static boolean factoryConstructorDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, CONST, EXTERNAL, FACTORY)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, FACTORY_CONSTRUCTOR_DECLARATION, ""); - r = factoryConstructorDeclaration_0(b, l + 1); - r = r && factoryConstructorDeclaration_1(b, l + 1); - r = r && factoryConstructorDeclaration_2(b, l + 1); - r = r && consumeToken(b, FACTORY); - p = r; // pin = 4 - r = r && report_error_(b, componentName(b, l + 1)); - r = p && report_error_(b, factoryConstructorDeclaration_5(b, l + 1)) && r; - r = p && report_error_(b, formalParameterList(b, l + 1)) && r; - r = p && factoryConstructorDeclaration_7(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FACTORY_CONSTRUCTOR_DECLARATION, ""); + result_ = factoryConstructorDeclaration_0(builder_, level_ + 1); + result_ = result_ && factoryConstructorDeclaration_1(builder_, level_ + 1); + result_ = result_ && factoryConstructorDeclaration_2(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, FACTORY); + pinned_ = result_; // pin = 4 + result_ = result_ && report_error_(builder_, componentName(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, factoryConstructorDeclaration_5(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, formalParameterList(builder_, level_ + 1)) && result_; + result_ = pinned_ && factoryConstructorDeclaration_7(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean factoryConstructorDeclaration_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_0")) return false; + private static boolean factoryConstructorDeclaration_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "factoryConstructorDeclaration_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "factoryConstructorDeclaration_0", pos_)) break; } return true; } // 'augment'? - private static boolean factoryConstructorDeclaration_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_1")) return false; - consumeToken(b, AUGMENT); + private static boolean factoryConstructorDeclaration_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // ('external' | 'const')* - private static boolean factoryConstructorDeclaration_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_2")) return false; + private static boolean factoryConstructorDeclaration_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_2")) return false; while (true) { - int c = current_position_(b); - if (!factoryConstructorDeclaration_2_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "factoryConstructorDeclaration_2", c)) break; + int pos_ = current_position_(builder_); + if (!factoryConstructorDeclaration_2_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "factoryConstructorDeclaration_2", pos_)) break; } return true; } // 'external' | 'const' - private static boolean factoryConstructorDeclaration_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_2_0")) return false; - boolean r; - r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, CONST); - return r; + private static boolean factoryConstructorDeclaration_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_2_0")) return false; + boolean result_; + result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, CONST); + return result_; } // ('.' componentName)? - private static boolean factoryConstructorDeclaration_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_5")) return false; - factoryConstructorDeclaration_5_0(b, l + 1); + private static boolean factoryConstructorDeclaration_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_5")) return false; + factoryConstructorDeclaration_5_0(builder_, level_ + 1); return true; } // '.' componentName - private static boolean factoryConstructorDeclaration_5_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_5_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, DOT); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean factoryConstructorDeclaration_5_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_5_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, DOT); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // factoryTail? - private static boolean factoryConstructorDeclaration_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryConstructorDeclaration_7")) return false; - factoryTail(b, l + 1); + private static boolean factoryConstructorDeclaration_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryConstructorDeclaration_7")) return false; + factoryTail(builder_, level_ + 1); return true; } /* ********************************************************** */ // varFactoryDeclaration ';' | functionBodyOrNative | ';' - static boolean factoryTail(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryTail")) return false; - boolean r; - Marker m = enter_section_(b); - r = factoryTail_0(b, l + 1); - if (!r) r = functionBodyOrNative(b, l + 1); - if (!r) r = consumeToken(b, SEMICOLON); - exit_section_(b, m, null, r); - return r; + static boolean factoryTail(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryTail")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = factoryTail_0(builder_, level_ + 1); + if (!result_) result_ = functionBodyOrNative(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, SEMICOLON); + exit_section_(builder_, marker_, null, result_); + return result_; } // varFactoryDeclaration ';' - private static boolean factoryTail_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "factoryTail_0")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = varFactoryDeclaration(b, l + 1); - p = r; // pin = 1 - r = r && consumeToken(b, SEMICOLON); - exit_section_(b, l, m, r, p, null); - return r || p; + private static boolean factoryTail_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "factoryTail_0")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = varFactoryDeclaration(builder_, level_ + 1); + pinned_ = result_; // pin = 1 + result_ = result_ && consumeToken(builder_, SEMICOLON); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // metadata* 'required'? finalConstVarVoidOrType? ('this' | 'super') '.' referenceExpression typeParameters? formalParameterList? - public static boolean fieldFormalParameter(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FIELD_FORMAL_PARAMETER, ""); - r = fieldFormalParameter_0(b, l + 1); - r = r && fieldFormalParameter_1(b, l + 1); - r = r && fieldFormalParameter_2(b, l + 1); - r = r && fieldFormalParameter_3(b, l + 1); - r = r && consumeToken(b, DOT); - r = r && referenceExpression(b, l + 1); - r = r && fieldFormalParameter_6(b, l + 1); - r = r && fieldFormalParameter_7(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean fieldFormalParameter(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FIELD_FORMAL_PARAMETER, ""); + result_ = fieldFormalParameter_0(builder_, level_ + 1); + result_ = result_ && fieldFormalParameter_1(builder_, level_ + 1); + result_ = result_ && fieldFormalParameter_2(builder_, level_ + 1); + result_ = result_ && fieldFormalParameter_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, DOT); + result_ = result_ && referenceExpression(builder_, level_ + 1); + result_ = result_ && fieldFormalParameter_6(builder_, level_ + 1); + result_ = result_ && fieldFormalParameter_7(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* - private static boolean fieldFormalParameter_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_0")) return false; + private static boolean fieldFormalParameter_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "fieldFormalParameter_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "fieldFormalParameter_0", pos_)) break; } return true; } // 'required'? - private static boolean fieldFormalParameter_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_1")) return false; - consumeToken(b, REQUIRED); + private static boolean fieldFormalParameter_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_1")) return false; + consumeToken(builder_, REQUIRED); return true; } // finalConstVarVoidOrType? - private static boolean fieldFormalParameter_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_2")) return false; - finalConstVarVoidOrType(b, l + 1); + private static boolean fieldFormalParameter_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_2")) return false; + finalConstVarVoidOrType(builder_, level_ + 1); return true; } // 'this' | 'super' - private static boolean fieldFormalParameter_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_3")) return false; - boolean r; - r = consumeToken(b, THIS); - if (!r) r = consumeToken(b, SUPER); - return r; + private static boolean fieldFormalParameter_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_3")) return false; + boolean result_; + result_ = consumeToken(builder_, THIS); + if (!result_) result_ = consumeToken(builder_, SUPER); + return result_; } // typeParameters? - private static boolean fieldFormalParameter_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_6")) return false; - typeParameters(b, l + 1); + private static boolean fieldFormalParameter_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_6")) return false; + typeParameters(builder_, level_ + 1); return true; } // formalParameterList? - private static boolean fieldFormalParameter_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldFormalParameter_7")) return false; - formalParameterList(b, l + 1); + private static boolean fieldFormalParameter_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldFormalParameter_7")) return false; + formalParameterList(builder_, level_ + 1); return true; } /* ********************************************************** */ // ('this' '.')? referenceExpression '=' expression - public static boolean fieldInitializer(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldInitializer")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, FIELD_INITIALIZER, ""); - r = fieldInitializer_0(b, l + 1); - r = r && referenceExpression(b, l + 1); - p = r; // pin = 2 - r = r && report_error_(b, consumeToken(b, EQ)); - r = p && expression(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean fieldInitializer(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldInitializer")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FIELD_INITIALIZER, ""); + result_ = fieldInitializer_0(builder_, level_ + 1); + result_ = result_ && referenceExpression(builder_, level_ + 1); + pinned_ = result_; // pin = 2 + result_ = result_ && report_error_(builder_, consumeToken(builder_, EQ)); + result_ = pinned_ && expression(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // ('this' '.')? - private static boolean fieldInitializer_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldInitializer_0")) return false; - fieldInitializer_0_0(b, l + 1); + private static boolean fieldInitializer_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldInitializer_0")) return false; + fieldInitializer_0_0(builder_, level_ + 1); return true; } // 'this' '.' - private static boolean fieldInitializer_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "fieldInitializer_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, THIS, DOT); - exit_section_(b, m, null, r); - return r; + private static boolean fieldInitializer_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "fieldInitializer_0_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, THIS, DOT); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ @@ -2515,413 +2515,413 @@ private static boolean fieldInitializer_0_0(PsiBuilder b, int l) { // 'covariant' type componentName | // 'late' type componentName | // type componentName - static boolean finalConstVarOrTypeAndComponentName(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_0(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_1(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_2(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_3(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_4(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_5(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_6(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_7(b, l + 1); - if (!r) r = finalConstVarOrTypeAndComponentName_8(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean finalConstVarOrTypeAndComponentName(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_0(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_1(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_2(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_3(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_4(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_5(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_6(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_7(builder_, level_ + 1); + if (!result_) result_ = finalConstVarOrTypeAndComponentName_8(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? 'late'? 'final' type componentName - private static boolean finalConstVarOrTypeAndComponentName_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_0_0(b, l + 1); - r = r && finalConstVarOrTypeAndComponentName_0_1(b, l + 1); - r = r && consumeToken(b, FINAL); - r = r && type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_0_0(builder_, level_ + 1); + result_ = result_ && finalConstVarOrTypeAndComponentName_0_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, FINAL); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? - private static boolean finalConstVarOrTypeAndComponentName_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_0_0")) return false; - consumeToken(b, COVARIANT); + private static boolean finalConstVarOrTypeAndComponentName_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_0_0")) return false; + consumeToken(builder_, COVARIANT); return true; } // 'late'? - private static boolean finalConstVarOrTypeAndComponentName_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_0_1")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarOrTypeAndComponentName_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_0_1")) return false; + consumeToken(builder_, LATE); return true; } // 'covariant'? 'late'? 'final' componentName - private static boolean finalConstVarOrTypeAndComponentName_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_1_0(b, l + 1); - r = r && finalConstVarOrTypeAndComponentName_1_1(b, l + 1); - r = r && consumeToken(b, FINAL); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_1_0(builder_, level_ + 1); + result_ = result_ && finalConstVarOrTypeAndComponentName_1_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, FINAL); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? - private static boolean finalConstVarOrTypeAndComponentName_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_1_0")) return false; - consumeToken(b, COVARIANT); + private static boolean finalConstVarOrTypeAndComponentName_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_1_0")) return false; + consumeToken(builder_, COVARIANT); return true; } // 'late'? - private static boolean finalConstVarOrTypeAndComponentName_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_1_1")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarOrTypeAndComponentName_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_1_1")) return false; + consumeToken(builder_, LATE); return true; } // 'covariant'? 'const' type componentName - private static boolean finalConstVarOrTypeAndComponentName_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_2_0(b, l + 1); - r = r && consumeToken(b, CONST); - r = r && type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_2_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, CONST); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? - private static boolean finalConstVarOrTypeAndComponentName_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_2_0")) return false; - consumeToken(b, COVARIANT); + private static boolean finalConstVarOrTypeAndComponentName_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_2_0")) return false; + consumeToken(builder_, COVARIANT); return true; } // 'covariant'? 'const' componentName - private static boolean finalConstVarOrTypeAndComponentName_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_3_0(b, l + 1); - r = r && consumeToken(b, CONST); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_3_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, CONST); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? - private static boolean finalConstVarOrTypeAndComponentName_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_3_0")) return false; - consumeToken(b, COVARIANT); + private static boolean finalConstVarOrTypeAndComponentName_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_3_0")) return false; + consumeToken(builder_, COVARIANT); return true; } // 'covariant'? 'late'? 'var' componentName - private static boolean finalConstVarOrTypeAndComponentName_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_4")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarOrTypeAndComponentName_4_0(b, l + 1); - r = r && finalConstVarOrTypeAndComponentName_4_1(b, l + 1); - r = r && consumeToken(b, VAR); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_4")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarOrTypeAndComponentName_4_0(builder_, level_ + 1); + result_ = result_ && finalConstVarOrTypeAndComponentName_4_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, VAR); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant'? - private static boolean finalConstVarOrTypeAndComponentName_4_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_4_0")) return false; - consumeToken(b, COVARIANT); + private static boolean finalConstVarOrTypeAndComponentName_4_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_4_0")) return false; + consumeToken(builder_, COVARIANT); return true; } // 'late'? - private static boolean finalConstVarOrTypeAndComponentName_4_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_4_1")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarOrTypeAndComponentName_4_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_4_1")) return false; + consumeToken(builder_, LATE); return true; } // 'covariant' 'late' type componentName - private static boolean finalConstVarOrTypeAndComponentName_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_5")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, COVARIANT, LATE); - r = r && type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_5")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, COVARIANT, LATE); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'covariant' type componentName - private static boolean finalConstVarOrTypeAndComponentName_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_6")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COVARIANT); - r = r && type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_6")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COVARIANT); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'late' type componentName - private static boolean finalConstVarOrTypeAndComponentName_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_7")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LATE); - r = r && type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_7")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LATE); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // type componentName - private static boolean finalConstVarOrTypeAndComponentName_8(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_8")) return false; - boolean r; - Marker m = enter_section_(b); - r = type(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarOrTypeAndComponentName_8(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarOrTypeAndComponentName_8")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = type(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'late'? 'final' type? | 'const' type? | 'late'? 'var' | 'late'? 'void' | 'late' type | type - static boolean finalConstVarVoidOrType(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarVoidOrType_0(b, l + 1); - if (!r) r = finalConstVarVoidOrType_1(b, l + 1); - if (!r) r = finalConstVarVoidOrType_2(b, l + 1); - if (!r) r = finalConstVarVoidOrType_3(b, l + 1); - if (!r) r = finalConstVarVoidOrType_4(b, l + 1); - if (!r) r = type(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean finalConstVarVoidOrType(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarVoidOrType_0(builder_, level_ + 1); + if (!result_) result_ = finalConstVarVoidOrType_1(builder_, level_ + 1); + if (!result_) result_ = finalConstVarVoidOrType_2(builder_, level_ + 1); + if (!result_) result_ = finalConstVarVoidOrType_3(builder_, level_ + 1); + if (!result_) result_ = finalConstVarVoidOrType_4(builder_, level_ + 1); + if (!result_) result_ = type(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'late'? 'final' type? - private static boolean finalConstVarVoidOrType_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarVoidOrType_0_0(b, l + 1); - r = r && consumeToken(b, FINAL); - r = r && finalConstVarVoidOrType_0_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarVoidOrType_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarVoidOrType_0_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, FINAL); + result_ = result_ && finalConstVarVoidOrType_0_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'late'? - private static boolean finalConstVarVoidOrType_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_0_0")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarVoidOrType_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_0_0")) return false; + consumeToken(builder_, LATE); return true; } // type? - private static boolean finalConstVarVoidOrType_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_0_2")) return false; - type(b, l + 1); + private static boolean finalConstVarVoidOrType_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_0_2")) return false; + type(builder_, level_ + 1); return true; } // 'const' type? - private static boolean finalConstVarVoidOrType_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, CONST); - r = r && finalConstVarVoidOrType_1_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarVoidOrType_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, CONST); + result_ = result_ && finalConstVarVoidOrType_1_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // type? - private static boolean finalConstVarVoidOrType_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_1_1")) return false; - type(b, l + 1); + private static boolean finalConstVarVoidOrType_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_1_1")) return false; + type(builder_, level_ + 1); return true; } // 'late'? 'var' - private static boolean finalConstVarVoidOrType_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarVoidOrType_2_0(b, l + 1); - r = r && consumeToken(b, VAR); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarVoidOrType_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarVoidOrType_2_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, VAR); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'late'? - private static boolean finalConstVarVoidOrType_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_2_0")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarVoidOrType_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_2_0")) return false; + consumeToken(builder_, LATE); return true; } // 'late'? 'void' - private static boolean finalConstVarVoidOrType_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = finalConstVarVoidOrType_3_0(b, l + 1); - r = r && consumeToken(b, VOID); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarVoidOrType_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = finalConstVarVoidOrType_3_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, VOID); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'late'? - private static boolean finalConstVarVoidOrType_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_3_0")) return false; - consumeToken(b, LATE); + private static boolean finalConstVarVoidOrType_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_3_0")) return false; + consumeToken(builder_, LATE); return true; } // 'late' type - private static boolean finalConstVarVoidOrType_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalConstVarVoidOrType_4")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LATE); - r = r && type(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean finalConstVarVoidOrType_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalConstVarVoidOrType_4")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LATE); + result_ = result_ && type(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'final' | 'const' - static boolean finalOrConst(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finalOrConst")) return false; - if (!nextTokenIs(b, "", CONST, FINAL)) return false; - boolean r; - r = consumeToken(b, FINAL); - if (!r) r = consumeToken(b, CONST); - return r; + static boolean finalOrConst(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finalOrConst")) return false; + if (!nextTokenIs(builder_, "", CONST, FINAL)) return false; + boolean result_; + result_ = consumeToken(builder_, FINAL); + if (!result_) result_ = consumeToken(builder_, CONST); + return result_; } /* ********************************************************** */ // 'finally' block - public static boolean finallyPart(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "finallyPart")) return false; - if (!nextTokenIs(b, FINALLY)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, FINALLY_PART, null); - r = consumeToken(b, FINALLY); - p = r; // pin = 1 - r = r && block(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean finallyPart(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "finallyPart")) return false; + if (!nextTokenIs(builder_, FINALLY)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FINALLY_PART, null); + result_ = consumeToken(builder_, FINALLY); + pinned_ = result_; // pin = 1 + result_ = result_ && block(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // 'await'? 'for' '(' forLoopParts ')' element - public static boolean forElement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forElement")) return false; - if (!nextTokenIs(b, "", AWAIT, FOR)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, FOR_ELEMENT, ""); - r = forElement_0(b, l + 1); - r = r && consumeTokens(b, 1, FOR, LPAREN); - p = r; // pin = 2 - r = r && report_error_(b, forLoopParts(b, l + 1)); - r = p && report_error_(b, consumeToken(b, RPAREN)) && r; - r = p && element(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean forElement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forElement")) return false; + if (!nextTokenIs(builder_, "", AWAIT, FOR)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FOR_ELEMENT, ""); + result_ = forElement_0(builder_, level_ + 1); + result_ = result_ && consumeTokens(builder_, 1, FOR, LPAREN); + pinned_ = result_; // pin = 2 + result_ = result_ && report_error_(builder_, forLoopParts(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, consumeToken(builder_, RPAREN)) && result_; + result_ = pinned_ && element(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // 'await'? - private static boolean forElement_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forElement_0")) return false; - consumeToken(b, AWAIT); + private static boolean forElement_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forElement_0")) return false; + consumeToken(builder_, AWAIT); return true; } /* ********************************************************** */ // (varAccessDeclaration | componentName) 'in' expression | // metadata* ( 'final' | 'var' ) outerPattern 'in' expression - public static boolean forInPart(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FOR_IN_PART, ""); - r = forInPart_0(b, l + 1); - if (!r) r = forInPart_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean forInPart(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FOR_IN_PART, ""); + result_ = forInPart_0(builder_, level_ + 1); + if (!result_) result_ = forInPart_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // (varAccessDeclaration | componentName) 'in' expression - private static boolean forInPart_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = forInPart_0_0(b, l + 1); - r = r && consumeToken(b, IN); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forInPart_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = forInPart_0_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, IN); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // varAccessDeclaration | componentName - private static boolean forInPart_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart_0_0")) return false; - boolean r; - r = varAccessDeclaration(b, l + 1); - if (!r) r = componentName(b, l + 1); - return r; + private static boolean forInPart_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart_0_0")) return false; + boolean result_; + result_ = varAccessDeclaration(builder_, level_ + 1); + if (!result_) result_ = componentName(builder_, level_ + 1); + return result_; } // metadata* ( 'final' | 'var' ) outerPattern 'in' expression - private static boolean forInPart_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = forInPart_1_0(b, l + 1); - r = r && forInPart_1_1(b, l + 1); - r = r && outerPattern(b, l + 1); - r = r && consumeToken(b, IN); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forInPart_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = forInPart_1_0(builder_, level_ + 1); + result_ = result_ && forInPart_1_1(builder_, level_ + 1); + result_ = result_ && outerPattern(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, IN); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean forInPart_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart_1_0")) return false; + private static boolean forInPart_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart_1_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "forInPart_1_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "forInPart_1_0", pos_)) break; } return true; } // 'final' | 'var' - private static boolean forInPart_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forInPart_1_1")) return false; - boolean r; - r = consumeToken(b, FINAL); - if (!r) r = consumeToken(b, VAR); - return r; + private static boolean forInPart_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forInPart_1_1")) return false; + boolean result_; + result_ = consumeToken(builder_, FINAL); + if (!result_) result_ = consumeToken(builder_, VAR); + return result_; } /* ********************************************************** */ @@ -2929,576 +2929,576 @@ private static boolean forInPart_1_1(PsiBuilder b, int l) { // | varDeclarationList (';' expression? (';' expressionList?)?)? // | patternVariableDeclaration (';' expression? (';' expressionList?)?)? // | expressionList? (';' expression? (';' expressionList?)?)? - public static boolean forLoopParts(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FOR_LOOP_PARTS, ""); - r = forInPart(b, l + 1); - if (!r) r = forLoopParts_1(b, l + 1); - if (!r) r = forLoopParts_2(b, l + 1); - if (!r) r = forLoopParts_3(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::for_loops_parts_recover); - return r; + public static boolean forLoopParts(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FOR_LOOP_PARTS, ""); + result_ = forInPart(builder_, level_ + 1); + if (!result_) result_ = forLoopParts_1(builder_, level_ + 1); + if (!result_) result_ = forLoopParts_2(builder_, level_ + 1); + if (!result_) result_ = forLoopParts_3(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::for_loops_parts_recover); + return result_; } // varDeclarationList (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = varDeclarationList(b, l + 1); - r = r && forLoopParts_1_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = varDeclarationList(builder_, level_ + 1); + result_ = result_ && forLoopParts_1_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1")) return false; - forLoopParts_1_1_0(b, l + 1); + private static boolean forLoopParts_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1")) return false; + forLoopParts_1_1_0(builder_, level_ + 1); return true; } // ';' expression? (';' expressionList?)? - private static boolean forLoopParts_1_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_1_1_0_1(b, l + 1); - r = r && forLoopParts_1_1_0_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_1_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_1_1_0_1(builder_, level_ + 1); + result_ = result_ && forLoopParts_1_1_0_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expression? - private static boolean forLoopParts_1_1_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1_0_1")) return false; - expression(b, l + 1); + private static boolean forLoopParts_1_1_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1_0_1")) return false; + expression(builder_, level_ + 1); return true; } // (';' expressionList?)? - private static boolean forLoopParts_1_1_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2")) return false; - forLoopParts_1_1_0_2_0(b, l + 1); + private static boolean forLoopParts_1_1_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1_0_2")) return false; + forLoopParts_1_1_0_2_0(builder_, level_ + 1); return true; } // ';' expressionList? - private static boolean forLoopParts_1_1_0_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_1_1_0_2_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_1_1_0_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1_0_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_1_1_0_2_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expressionList? - private static boolean forLoopParts_1_1_0_2_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2_0_1")) return false; - expressionList(b, l + 1); + private static boolean forLoopParts_1_1_0_2_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_1_1_0_2_0_1")) return false; + expressionList(builder_, level_ + 1); return true; } // patternVariableDeclaration (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = patternVariableDeclaration(b, l + 1); - r = r && forLoopParts_2_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = patternVariableDeclaration(builder_, level_ + 1); + result_ = result_ && forLoopParts_2_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_2_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1")) return false; - forLoopParts_2_1_0(b, l + 1); + private static boolean forLoopParts_2_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1")) return false; + forLoopParts_2_1_0(builder_, level_ + 1); return true; } // ';' expression? (';' expressionList?)? - private static boolean forLoopParts_2_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_2_1_0_1(b, l + 1); - r = r && forLoopParts_2_1_0_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_2_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_2_1_0_1(builder_, level_ + 1); + result_ = result_ && forLoopParts_2_1_0_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expression? - private static boolean forLoopParts_2_1_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1_0_1")) return false; - expression(b, l + 1); + private static boolean forLoopParts_2_1_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1_0_1")) return false; + expression(builder_, level_ + 1); return true; } // (';' expressionList?)? - private static boolean forLoopParts_2_1_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2")) return false; - forLoopParts_2_1_0_2_0(b, l + 1); + private static boolean forLoopParts_2_1_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1_0_2")) return false; + forLoopParts_2_1_0_2_0(builder_, level_ + 1); return true; } // ';' expressionList? - private static boolean forLoopParts_2_1_0_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_2_1_0_2_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_2_1_0_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1_0_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_2_1_0_2_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expressionList? - private static boolean forLoopParts_2_1_0_2_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2_0_1")) return false; - expressionList(b, l + 1); + private static boolean forLoopParts_2_1_0_2_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_2_1_0_2_0_1")) return false; + expressionList(builder_, level_ + 1); return true; } // expressionList? (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = forLoopParts_3_0(b, l + 1); - r = r && forLoopParts_3_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = forLoopParts_3_0(builder_, level_ + 1); + result_ = result_ && forLoopParts_3_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expressionList? - private static boolean forLoopParts_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_0")) return false; - expressionList(b, l + 1); + private static boolean forLoopParts_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_0")) return false; + expressionList(builder_, level_ + 1); return true; } // (';' expression? (';' expressionList?)?)? - private static boolean forLoopParts_3_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1")) return false; - forLoopParts_3_1_0(b, l + 1); + private static boolean forLoopParts_3_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1")) return false; + forLoopParts_3_1_0(builder_, level_ + 1); return true; } // ';' expression? (';' expressionList?)? - private static boolean forLoopParts_3_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_3_1_0_1(b, l + 1); - r = r && forLoopParts_3_1_0_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_3_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_3_1_0_1(builder_, level_ + 1); + result_ = result_ && forLoopParts_3_1_0_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expression? - private static boolean forLoopParts_3_1_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1_0_1")) return false; - expression(b, l + 1); + private static boolean forLoopParts_3_1_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1_0_1")) return false; + expression(builder_, level_ + 1); return true; } // (';' expressionList?)? - private static boolean forLoopParts_3_1_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1_0_2")) return false; - forLoopParts_3_1_0_2_0(b, l + 1); + private static boolean forLoopParts_3_1_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1_0_2")) return false; + forLoopParts_3_1_0_2_0(builder_, level_ + 1); return true; } // ';' expressionList? - private static boolean forLoopParts_3_1_0_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1_0_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, SEMICOLON); - r = r && forLoopParts_3_1_0_2_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean forLoopParts_3_1_0_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1_0_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, SEMICOLON); + result_ = result_ && forLoopParts_3_1_0_2_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // expressionList? - private static boolean forLoopParts_3_1_0_2_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopParts_3_1_0_2_0_1")) return false; - expressionList(b, l + 1); + private static boolean forLoopParts_3_1_0_2_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopParts_3_1_0_2_0_1")) return false; + expressionList(builder_, level_ + 1); return true; } /* ********************************************************** */ // '(' forLoopParts ')' - public static boolean forLoopPartsInBraces(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forLoopPartsInBraces")) return false; - if (!nextTokenIs(b, LPAREN)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LPAREN); - r = r && forLoopParts(b, l + 1); - r = r && consumeToken(b, RPAREN); - exit_section_(b, m, FOR_LOOP_PARTS_IN_BRACES, r); - return r; + public static boolean forLoopPartsInBraces(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forLoopPartsInBraces")) return false; + if (!nextTokenIs(builder_, LPAREN)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LPAREN); + result_ = result_ && forLoopParts(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RPAREN); + exit_section_(builder_, marker_, FOR_LOOP_PARTS_IN_BRACES, result_); + return result_; } /* ********************************************************** */ // 'await'? 'for' forLoopPartsInBraces statement - public static boolean forStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forStatement")) return false; - if (!nextTokenIs(b, "", AWAIT, FOR)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, FOR_STATEMENT, ""); - r = forStatement_0(b, l + 1); - r = r && consumeToken(b, FOR); - p = r; // pin = 2 - r = r && report_error_(b, forLoopPartsInBraces(b, l + 1)); - r = p && statement(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean forStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forStatement")) return false; + if (!nextTokenIs(builder_, "", AWAIT, FOR)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FOR_STATEMENT, ""); + result_ = forStatement_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, FOR); + pinned_ = result_; // pin = 2 + result_ = result_ && report_error_(builder_, forLoopPartsInBraces(builder_, level_ + 1)); + result_ = pinned_ && statement(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // 'await'? - private static boolean forStatement_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "forStatement_0")) return false; - consumeToken(b, AWAIT); + private static boolean forStatement_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "forStatement_0")) return false; + consumeToken(builder_, AWAIT); return true; } /* ********************************************************** */ // !')' - static boolean for_loops_parts_recover(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "for_loops_parts_recover")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !consumeToken(b, RPAREN); - exit_section_(b, l, m, r, false, null); - return r; + static boolean for_loops_parts_recover(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "for_loops_parts_recover")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !consumeToken(builder_, RPAREN); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // '(' ')' | // '(' normalFormalParameters (',' optionalFormalParameters)? ','? ')' | // '(' optionalFormalParameters ')' - public static boolean formalParameterList(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList")) return false; - if (!nextTokenIs(b, LPAREN)) return false; - boolean r; - Marker m = enter_section_(b); - r = parseTokens(b, 0, LPAREN, RPAREN); - if (!r) r = formalParameterList_1(b, l + 1); - if (!r) r = formalParameterList_2(b, l + 1); - exit_section_(b, m, FORMAL_PARAMETER_LIST, r); - return r; + public static boolean formalParameterList(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList")) return false; + if (!nextTokenIs(builder_, LPAREN)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = parseTokens(builder_, 0, LPAREN, RPAREN); + if (!result_) result_ = formalParameterList_1(builder_, level_ + 1); + if (!result_) result_ = formalParameterList_2(builder_, level_ + 1); + exit_section_(builder_, marker_, FORMAL_PARAMETER_LIST, result_); + return result_; } // '(' normalFormalParameters (',' optionalFormalParameters)? ','? ')' - private static boolean formalParameterList_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LPAREN); - r = r && normalFormalParameters(b, l + 1); - r = r && formalParameterList_1_2(b, l + 1); - r = r && formalParameterList_1_3(b, l + 1); - r = r && consumeToken(b, RPAREN); - exit_section_(b, m, null, r); - return r; + private static boolean formalParameterList_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LPAREN); + result_ = result_ && normalFormalParameters(builder_, level_ + 1); + result_ = result_ && formalParameterList_1_2(builder_, level_ + 1); + result_ = result_ && formalParameterList_1_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RPAREN); + exit_section_(builder_, marker_, null, result_); + return result_; } // (',' optionalFormalParameters)? - private static boolean formalParameterList_1_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList_1_2")) return false; - formalParameterList_1_2_0(b, l + 1); + private static boolean formalParameterList_1_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList_1_2")) return false; + formalParameterList_1_2_0(builder_, level_ + 1); return true; } // ',' optionalFormalParameters - private static boolean formalParameterList_1_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList_1_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && optionalFormalParameters(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean formalParameterList_1_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList_1_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && optionalFormalParameters(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ','? - private static boolean formalParameterList_1_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList_1_3")) return false; - consumeToken(b, COMMA); + private static boolean formalParameterList_1_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList_1_3")) return false; + consumeToken(builder_, COMMA); return true; } // '(' optionalFormalParameters ')' - private static boolean formalParameterList_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "formalParameterList_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LPAREN); - r = r && optionalFormalParameters(b, l + 1); - r = r && consumeToken(b, RPAREN); - exit_section_(b, m, null, r); - return r; + private static boolean formalParameterList_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "formalParameterList_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LPAREN); + result_ = result_ && optionalFormalParameters(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RPAREN); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // arrowBodyWithSemi | <> - public static boolean functionBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionBody")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_BODY, ""); - r = arrowBodyWithSemi(b, l + 1); - if (!r) r = blockBodyWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionBody")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_BODY, ""); + result_ = arrowBodyWithSemi(builder_, level_ + 1); + if (!result_) result_ = blockBodyWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // 'native' functionBody // | functionNative // | functionBody - static boolean functionBodyOrNative(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionBodyOrNative")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionBodyOrNative_0(b, l + 1); - if (!r) r = functionNative(b, l + 1); - if (!r) r = functionBody(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean functionBodyOrNative(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionBodyOrNative")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionBodyOrNative_0(builder_, level_ + 1); + if (!result_) result_ = functionNative(builder_, level_ + 1); + if (!result_) result_ = functionBody(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'native' functionBody - private static boolean functionBodyOrNative_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionBodyOrNative_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, NATIVE); - r = r && functionBody(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionBodyOrNative_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionBodyOrNative_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, NATIVE); + result_ = result_ && functionBody(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // metadata* 'augment'? (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) functionBody - public static boolean functionDeclarationWithBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_DECLARATION_WITH_BODY, ""); - r = functionDeclarationWithBody_0(b, l + 1); - r = r && functionDeclarationWithBody_1(b, l + 1); - r = r && functionDeclarationWithBody_2(b, l + 1); - r = r && functionBody(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionDeclarationWithBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_DECLARATION_WITH_BODY, ""); + result_ = functionDeclarationWithBody_0(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBody_1(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBody_2(builder_, level_ + 1); + result_ = result_ && functionBody(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* - private static boolean functionDeclarationWithBody_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_0")) return false; + private static boolean functionDeclarationWithBody_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionDeclarationWithBody_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionDeclarationWithBody_0", pos_)) break; } return true; } // 'augment'? - private static boolean functionDeclarationWithBody_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_1")) return false; - consumeToken(b, AUGMENT); + private static boolean functionDeclarationWithBody_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBody_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionDeclarationWithBody_2_0(b, l + 1); - if (!r) r = functionDeclarationWithBody_2_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBody_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionDeclarationWithBody_2_0(builder_, level_ + 1); + if (!result_) result_ = functionDeclarationWithBody_2_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // returnType componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBody_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = returnType(b, l + 1); - r = r && componentName(b, l + 1); - r = r && functionDeclarationWithBody_2_0_2(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBody_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = returnType(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBody_2_0_2(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeParameters? - private static boolean functionDeclarationWithBody_2_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_2_0_2")) return false; - typeParameters(b, l + 1); + private static boolean functionDeclarationWithBody_2_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_2_0_2")) return false; + typeParameters(builder_, level_ + 1); return true; } // componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBody_2_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_2_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = componentName(b, l + 1); - r = r && functionDeclarationWithBody_2_1_1(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBody_2_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_2_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = componentName(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBody_2_1_1(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeParameters? - private static boolean functionDeclarationWithBody_2_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBody_2_1_1")) return false; - typeParameters(b, l + 1); + private static boolean functionDeclarationWithBody_2_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBody_2_1_1")) return false; + typeParameters(builder_, level_ + 1); return true; } /* ********************************************************** */ // metadata* 'augment'? 'external'? (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) ( ';' | functionBodyOrNative) - public static boolean functionDeclarationWithBodyOrNative(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_DECLARATION_WITH_BODY_OR_NATIVE, ""); - r = functionDeclarationWithBodyOrNative_0(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_1(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_2(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_3(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_4(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionDeclarationWithBodyOrNative(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_DECLARATION_WITH_BODY_OR_NATIVE, ""); + result_ = functionDeclarationWithBodyOrNative_0(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_1(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_2(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_3(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_4(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* - private static boolean functionDeclarationWithBodyOrNative_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_0")) return false; + private static boolean functionDeclarationWithBodyOrNative_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionDeclarationWithBodyOrNative_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionDeclarationWithBodyOrNative_0", pos_)) break; } return true; } // 'augment'? - private static boolean functionDeclarationWithBodyOrNative_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_1")) return false; - consumeToken(b, AUGMENT); + private static boolean functionDeclarationWithBodyOrNative_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // 'external'? - private static boolean functionDeclarationWithBodyOrNative_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2")) return false; - consumeToken(b, EXTERNAL); + private static boolean functionDeclarationWithBodyOrNative_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_2")) return false; + consumeToken(builder_, EXTERNAL); return true; } // returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBodyOrNative_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionDeclarationWithBodyOrNative_3_0(b, l + 1); - if (!r) r = functionDeclarationWithBodyOrNative_3_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBodyOrNative_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_3")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionDeclarationWithBodyOrNative_3_0(builder_, level_ + 1); + if (!result_) result_ = functionDeclarationWithBodyOrNative_3_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // returnType componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBodyOrNative_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = returnType(b, l + 1); - r = r && componentName(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_3_0_2(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBodyOrNative_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_3_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = returnType(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_3_0_2(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeParameters? - private static boolean functionDeclarationWithBodyOrNative_3_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3_0_2")) return false; - typeParameters(b, l + 1); + private static boolean functionDeclarationWithBodyOrNative_3_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_3_0_2")) return false; + typeParameters(builder_, level_ + 1); return true; } // componentName typeParameters? formalParameterList - private static boolean functionDeclarationWithBodyOrNative_3_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = componentName(b, l + 1); - r = r && functionDeclarationWithBodyOrNative_3_1_1(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionDeclarationWithBodyOrNative_3_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_3_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = componentName(builder_, level_ + 1); + result_ = result_ && functionDeclarationWithBodyOrNative_3_1_1(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // typeParameters? - private static boolean functionDeclarationWithBodyOrNative_3_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3_1_1")) return false; - typeParameters(b, l + 1); + private static boolean functionDeclarationWithBodyOrNative_3_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_3_1_1")) return false; + typeParameters(builder_, level_ + 1); return true; } // ';' | functionBodyOrNative - private static boolean functionDeclarationWithBodyOrNative_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_4")) return false; - boolean r; - r = consumeToken(b, SEMICOLON); - if (!r) r = functionBodyOrNative(b, l + 1); - return r; + private static boolean functionDeclarationWithBodyOrNative_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionDeclarationWithBodyOrNative_4")) return false; + boolean result_; + result_ = consumeToken(builder_, SEMICOLON); + if (!result_) result_ = functionBodyOrNative(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // typeParameters? formalParameterList functionExpressionBody - public static boolean functionExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionExpression")) return false; - if (!nextTokenIs(b, "", LPAREN, LT)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_EXPRESSION, ""); - r = functionExpression_0(b, l + 1); - r = r && formalParameterList(b, l + 1); - r = r && functionExpressionBody(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionExpression")) return false; + if (!nextTokenIs(builder_, "", LPAREN, LT)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_EXPRESSION, ""); + result_ = functionExpression_0(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + result_ = result_ && functionExpressionBody(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // typeParameters? - private static boolean functionExpression_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionExpression_0")) return false; - typeParameters(b, l + 1); + private static boolean functionExpression_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionExpression_0")) return false; + typeParameters(builder_, level_ + 1); return true; } /* ********************************************************** */ // <> | <> - public static boolean functionExpressionBody(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionExpressionBody")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_EXPRESSION_BODY, ""); - r = arrowBodyWrapper(b, l + 1); - if (!r) r = blockBodyWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionExpressionBody(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionExpressionBody")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_EXPRESSION_BODY, ""); + result_ = arrowBodyWrapper(builder_, level_ + 1); + if (!result_) result_ = blockBodyWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ @@ -3506,2427 +3506,2427 @@ public static boolean functionExpressionBody(PsiBuilder b, int l) { // metadata* 'covariant'? returnType componentName typeParameters? formalParameterList | // metadata* 'covariant' componentName typeParameters? formalParameterList) // '?'? - public static boolean functionFormalParameter(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_FORMAL_PARAMETER, ""); - r = functionFormalParameter_0(b, l + 1); - r = r && functionFormalParameter_1(b, l + 1); - r = r && functionFormalParameter_2(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionFormalParameter(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_FORMAL_PARAMETER, ""); + result_ = functionFormalParameter_0(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_1(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_2(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // !functionTypeWrapper - private static boolean functionFormalParameter_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_0")) return false; - boolean r; - Marker m = enter_section_(b, l, _NOT_); - r = !functionTypeWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + private static boolean functionFormalParameter_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NOT_); + result_ = !functionTypeWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* componentName typeParameters? formalParameterList | // metadata* 'covariant'? returnType componentName typeParameters? formalParameterList | // metadata* 'covariant' componentName typeParameters? formalParameterList - private static boolean functionFormalParameter_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionFormalParameter_1_0(b, l + 1); - if (!r) r = functionFormalParameter_1_1(b, l + 1); - if (!r) r = functionFormalParameter_1_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionFormalParameter_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionFormalParameter_1_0(builder_, level_ + 1); + if (!result_) result_ = functionFormalParameter_1_1(builder_, level_ + 1); + if (!result_) result_ = functionFormalParameter_1_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* componentName typeParameters? formalParameterList - private static boolean functionFormalParameter_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionFormalParameter_1_0_0(b, l + 1); - r = r && componentName(b, l + 1); - r = r && functionFormalParameter_1_0_2(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionFormalParameter_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionFormalParameter_1_0_0(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_1_0_2(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean functionFormalParameter_1_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_0_0")) return false; + private static boolean functionFormalParameter_1_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_0_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_0_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionFormalParameter_1_0_0", pos_)) break; } return true; } // typeParameters? - private static boolean functionFormalParameter_1_0_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_0_2")) return false; - typeParameters(b, l + 1); + private static boolean functionFormalParameter_1_0_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_0_2")) return false; + typeParameters(builder_, level_ + 1); return true; } // metadata* 'covariant'? returnType componentName typeParameters? formalParameterList - private static boolean functionFormalParameter_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionFormalParameter_1_1_0(b, l + 1); - r = r && functionFormalParameter_1_1_1(b, l + 1); - r = r && returnType(b, l + 1); - r = r && componentName(b, l + 1); - r = r && functionFormalParameter_1_1_4(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionFormalParameter_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionFormalParameter_1_1_0(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_1_1_1(builder_, level_ + 1); + result_ = result_ && returnType(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_1_1_4(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean functionFormalParameter_1_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_1_0")) return false; + private static boolean functionFormalParameter_1_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_1_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_1_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionFormalParameter_1_1_0", pos_)) break; } return true; } // 'covariant'? - private static boolean functionFormalParameter_1_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_1_1")) return false; - consumeToken(b, COVARIANT); + private static boolean functionFormalParameter_1_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_1_1")) return false; + consumeToken(builder_, COVARIANT); return true; } // typeParameters? - private static boolean functionFormalParameter_1_1_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_1_4")) return false; - typeParameters(b, l + 1); + private static boolean functionFormalParameter_1_1_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_1_4")) return false; + typeParameters(builder_, level_ + 1); return true; } // metadata* 'covariant' componentName typeParameters? formalParameterList - private static boolean functionFormalParameter_1_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionFormalParameter_1_2_0(b, l + 1); - r = r && consumeToken(b, COVARIANT); - r = r && componentName(b, l + 1); - r = r && functionFormalParameter_1_2_3(b, l + 1); - r = r && formalParameterList(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionFormalParameter_1_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionFormalParameter_1_2_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, COVARIANT); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionFormalParameter_1_2_3(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean functionFormalParameter_1_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_2_0")) return false; + private static boolean functionFormalParameter_1_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_2_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_2_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionFormalParameter_1_2_0", pos_)) break; } return true; } // typeParameters? - private static boolean functionFormalParameter_1_2_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_1_2_3")) return false; - typeParameters(b, l + 1); + private static boolean functionFormalParameter_1_2_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_1_2_3")) return false; + typeParameters(builder_, level_ + 1); return true; } // '?'? - private static boolean functionFormalParameter_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionFormalParameter_2")) return false; - consumeToken(b, QUEST); + private static boolean functionFormalParameter_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionFormalParameter_2")) return false; + consumeToken(builder_, QUEST); return true; } /* ********************************************************** */ // 'native' (stringLiteralExpression ';' | ';' | stringLiteralExpression functionBody) - static boolean functionNative(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionNative")) return false; - if (!nextTokenIs(b, NATIVE)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, NATIVE); - r = r && functionNative_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean functionNative(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionNative")) return false; + if (!nextTokenIs(builder_, NATIVE)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, NATIVE); + result_ = result_ && functionNative_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // stringLiteralExpression ';' | ';' | stringLiteralExpression functionBody - private static boolean functionNative_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionNative_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionNative_1_0(b, l + 1); - if (!r) r = consumeToken(b, SEMICOLON); - if (!r) r = functionNative_1_2(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionNative_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionNative_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionNative_1_0(builder_, level_ + 1); + if (!result_) result_ = consumeToken(builder_, SEMICOLON); + if (!result_) result_ = functionNative_1_2(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // stringLiteralExpression ';' - private static boolean functionNative_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionNative_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = stringLiteralExpression(b, l + 1); - r = r && consumeToken(b, SEMICOLON); - exit_section_(b, m, null, r); - return r; + private static boolean functionNative_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionNative_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = stringLiteralExpression(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, SEMICOLON); + exit_section_(builder_, marker_, null, result_); + return result_; } // stringLiteralExpression functionBody - private static boolean functionNative_1_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionNative_1_2")) return false; - boolean r; - Marker m = enter_section_(b); - r = stringLiteralExpression(b, l + 1); - r = r && functionBody(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionNative_1_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionNative_1_2")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = stringLiteralExpression(builder_, level_ + 1); + result_ = result_ && functionBody(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // returnType componentName | componentName - static boolean functionPrefix(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionPrefix")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionPrefix_0(b, l + 1); - if (!r) r = componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean functionPrefix(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionPrefix")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionPrefix_0(builder_, level_ + 1); + if (!result_) result_ = componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // returnType componentName - private static boolean functionPrefix_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionPrefix_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = returnType(b, l + 1); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionPrefix_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionPrefix_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = returnType(builder_, level_ + 1); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // metadata* 'augment'? 'typedef' functionPrefix typeParameters? formalParameterList ';'? | // metadata* 'augment'? 'typedef' componentName typeParameters? '=' type ';'? - public static boolean functionTypeAlias(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, TYPEDEF)) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, FUNCTION_TYPE_ALIAS, ""); - r = functionTypeAlias_0(b, l + 1); - if (!r) r = functionTypeAlias_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean functionTypeAlias(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, TYPEDEF)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, FUNCTION_TYPE_ALIAS, ""); + result_ = functionTypeAlias_0(builder_, level_ + 1); + if (!result_) result_ = functionTypeAlias_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* 'augment'? 'typedef' functionPrefix typeParameters? formalParameterList ';'? - private static boolean functionTypeAlias_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionTypeAlias_0_0(b, l + 1); - r = r && functionTypeAlias_0_1(b, l + 1); - r = r && consumeToken(b, TYPEDEF); - r = r && functionPrefix(b, l + 1); - r = r && functionTypeAlias_0_4(b, l + 1); - r = r && formalParameterList(b, l + 1); - r = r && functionTypeAlias_0_6(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionTypeAlias_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionTypeAlias_0_0(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_0_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, TYPEDEF); + result_ = result_ && functionPrefix(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_0_4(builder_, level_ + 1); + result_ = result_ && formalParameterList(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_0_6(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean functionTypeAlias_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_0_0")) return false; + private static boolean functionTypeAlias_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_0_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionTypeAlias_0_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionTypeAlias_0_0", pos_)) break; } return true; } // 'augment'? - private static boolean functionTypeAlias_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_0_1")) return false; - consumeToken(b, AUGMENT); + private static boolean functionTypeAlias_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_0_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeParameters? - private static boolean functionTypeAlias_0_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_0_4")) return false; - typeParameters(b, l + 1); + private static boolean functionTypeAlias_0_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_0_4")) return false; + typeParameters(builder_, level_ + 1); return true; } // ';'? - private static boolean functionTypeAlias_0_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_0_6")) return false; - consumeToken(b, SEMICOLON); + private static boolean functionTypeAlias_0_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_0_6")) return false; + consumeToken(builder_, SEMICOLON); return true; } // metadata* 'augment'? 'typedef' componentName typeParameters? '=' type ';'? - private static boolean functionTypeAlias_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionTypeAlias_1_0(b, l + 1); - r = r && functionTypeAlias_1_1(b, l + 1); - r = r && consumeToken(b, TYPEDEF); - r = r && componentName(b, l + 1); - r = r && functionTypeAlias_1_4(b, l + 1); - r = r && consumeToken(b, EQ); - r = r && type(b, l + 1); - r = r && functionTypeAlias_1_7(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionTypeAlias_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionTypeAlias_1_0(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_1_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, TYPEDEF); + result_ = result_ && componentName(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_1_4(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, EQ); + result_ = result_ && type(builder_, level_ + 1); + result_ = result_ && functionTypeAlias_1_7(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean functionTypeAlias_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_1_0")) return false; + private static boolean functionTypeAlias_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_1_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionTypeAlias_1_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionTypeAlias_1_0", pos_)) break; } return true; } // 'augment'? - private static boolean functionTypeAlias_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_1_1")) return false; - consumeToken(b, AUGMENT); + private static boolean functionTypeAlias_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_1_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // typeParameters? - private static boolean functionTypeAlias_1_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_1_4")) return false; - typeParameters(b, l + 1); + private static boolean functionTypeAlias_1_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_1_4")) return false; + typeParameters(builder_, level_ + 1); return true; } // ';'? - private static boolean functionTypeAlias_1_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeAlias_1_7")) return false; - consumeToken(b, SEMICOLON); + private static boolean functionTypeAlias_1_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeAlias_1_7")) return false; + consumeToken(builder_, SEMICOLON); return true; } /* ********************************************************** */ // (voidTypeFunctionType | untypedFunctionType | simpleType) typedFunctionType+ | untypedFunctionType - static boolean functionTypeWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionTypeWrapper_0(b, l + 1); - if (!r) r = untypedFunctionType(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean functionTypeWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionTypeWrapper_0(builder_, level_ + 1); + if (!result_) result_ = untypedFunctionType(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // (voidTypeFunctionType | untypedFunctionType | simpleType) typedFunctionType+ - private static boolean functionTypeWrapper_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeWrapper_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = functionTypeWrapper_0_0(b, l + 1); - r = r && functionTypeWrapper_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean functionTypeWrapper_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeWrapper_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = functionTypeWrapper_0_0(builder_, level_ + 1); + result_ = result_ && functionTypeWrapper_0_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // voidTypeFunctionType | untypedFunctionType | simpleType - private static boolean functionTypeWrapper_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeWrapper_0_0")) return false; - boolean r; - r = voidTypeFunctionType(b, l + 1); - if (!r) r = untypedFunctionType(b, l + 1); - if (!r) r = simpleType(b, l + 1); - return r; + private static boolean functionTypeWrapper_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeWrapper_0_0")) return false; + boolean result_; + result_ = voidTypeFunctionType(builder_, level_ + 1); + if (!result_) result_ = untypedFunctionType(builder_, level_ + 1); + if (!result_) result_ = simpleType(builder_, level_ + 1); + return result_; } // typedFunctionType+ - private static boolean functionTypeWrapper_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "functionTypeWrapper_0_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = typedFunctionType(b, l + 1); - while (r) { - int c = current_position_(b); - if (!typedFunctionType(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "functionTypeWrapper_0_1", c)) break; + private static boolean functionTypeWrapper_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "functionTypeWrapper_0_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = typedFunctionType(builder_, level_ + 1); + while (result_) { + int pos_ = current_position_(builder_); + if (!typedFunctionType(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "functionTypeWrapper_0_1", pos_)) break; } - exit_section_(b, m, null, r); - return r; + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // getterDeclarationWithReturnType | getterDeclarationWithoutReturnType - public static boolean getterDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclaration")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, GETTER_DECLARATION, ""); - r = getterDeclarationWithReturnType(b, l + 1); - if (!r) r = getterDeclarationWithoutReturnType(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean getterDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclaration")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, GETTER_DECLARATION, ""); + result_ = getterDeclarationWithReturnType(builder_, level_ + 1); + if (!result_) result_ = getterDeclarationWithoutReturnType(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // metadata* 'augment'? ('external' | 'static')* returnType 'get' componentName formalParameterList? (';' | functionBodyOrNative) - static boolean getterDeclarationWithReturnType(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = getterDeclarationWithReturnType_0(b, l + 1); - r = r && getterDeclarationWithReturnType_1(b, l + 1); - r = r && getterDeclarationWithReturnType_2(b, l + 1); - r = r && returnType(b, l + 1); - r = r && consumeToken(b, GET); - r = r && componentName(b, l + 1); - p = r; // pin = 6 - r = r && report_error_(b, getterDeclarationWithReturnType_6(b, l + 1)); - r = p && getterDeclarationWithReturnType_7(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + static boolean getterDeclarationWithReturnType(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType")) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = getterDeclarationWithReturnType_0(builder_, level_ + 1); + result_ = result_ && getterDeclarationWithReturnType_1(builder_, level_ + 1); + result_ = result_ && getterDeclarationWithReturnType_2(builder_, level_ + 1); + result_ = result_ && returnType(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, GET); + result_ = result_ && componentName(builder_, level_ + 1); + pinned_ = result_; // pin = 6 + result_ = result_ && report_error_(builder_, getterDeclarationWithReturnType_6(builder_, level_ + 1)); + result_ = pinned_ && getterDeclarationWithReturnType_7(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean getterDeclarationWithReturnType_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_0")) return false; + private static boolean getterDeclarationWithReturnType_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "getterDeclarationWithReturnType_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "getterDeclarationWithReturnType_0", pos_)) break; } return true; } // 'augment'? - private static boolean getterDeclarationWithReturnType_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_1")) return false; - consumeToken(b, AUGMENT); + private static boolean getterDeclarationWithReturnType_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // ('external' | 'static')* - private static boolean getterDeclarationWithReturnType_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_2")) return false; + private static boolean getterDeclarationWithReturnType_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_2")) return false; while (true) { - int c = current_position_(b); - if (!getterDeclarationWithReturnType_2_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "getterDeclarationWithReturnType_2", c)) break; + int pos_ = current_position_(builder_); + if (!getterDeclarationWithReturnType_2_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "getterDeclarationWithReturnType_2", pos_)) break; } return true; } // 'external' | 'static' - private static boolean getterDeclarationWithReturnType_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_2_0")) return false; - boolean r; - r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, STATIC); - return r; + private static boolean getterDeclarationWithReturnType_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_2_0")) return false; + boolean result_; + result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, STATIC); + return result_; } // formalParameterList? - private static boolean getterDeclarationWithReturnType_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_6")) return false; - formalParameterList(b, l + 1); + private static boolean getterDeclarationWithReturnType_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_6")) return false; + formalParameterList(builder_, level_ + 1); return true; } // ';' | functionBodyOrNative - private static boolean getterDeclarationWithReturnType_7(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_7")) return false; - boolean r; - r = consumeToken(b, SEMICOLON); - if (!r) r = functionBodyOrNative(b, l + 1); - return r; + private static boolean getterDeclarationWithReturnType_7(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithReturnType_7")) return false; + boolean result_; + result_ = consumeToken(builder_, SEMICOLON); + if (!result_) result_ = functionBodyOrNative(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // metadata* 'augment'? ('external' | 'static')* 'get' componentName formalParameterList? (';' | functionBodyOrNative) - static boolean getterDeclarationWithoutReturnType(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType")) return false; - if (!nextTokenIs(b, "", AT, AUGMENT, + static boolean getterDeclarationWithoutReturnType(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType")) return false; + if (!nextTokenIs(builder_, "", AT, AUGMENT, EXTERNAL, GET, STATIC)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_); - r = getterDeclarationWithoutReturnType_0(b, l + 1); - r = r && getterDeclarationWithoutReturnType_1(b, l + 1); - r = r && getterDeclarationWithoutReturnType_2(b, l + 1); - r = r && consumeToken(b, GET); - r = r && componentName(b, l + 1); - p = r; // pin = 5 - r = r && report_error_(b, getterDeclarationWithoutReturnType_5(b, l + 1)); - r = p && getterDeclarationWithoutReturnType_6(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = getterDeclarationWithoutReturnType_0(builder_, level_ + 1); + result_ = result_ && getterDeclarationWithoutReturnType_1(builder_, level_ + 1); + result_ = result_ && getterDeclarationWithoutReturnType_2(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, GET); + result_ = result_ && componentName(builder_, level_ + 1); + pinned_ = result_; // pin = 5 + result_ = result_ && report_error_(builder_, getterDeclarationWithoutReturnType_5(builder_, level_ + 1)); + result_ = pinned_ && getterDeclarationWithoutReturnType_6(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean getterDeclarationWithoutReturnType_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_0")) return false; + private static boolean getterDeclarationWithoutReturnType_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "getterDeclarationWithoutReturnType_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "getterDeclarationWithoutReturnType_0", pos_)) break; } return true; } // 'augment'? - private static boolean getterDeclarationWithoutReturnType_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_1")) return false; - consumeToken(b, AUGMENT); + private static boolean getterDeclarationWithoutReturnType_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_1")) return false; + consumeToken(builder_, AUGMENT); return true; } // ('external' | 'static')* - private static boolean getterDeclarationWithoutReturnType_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_2")) return false; + private static boolean getterDeclarationWithoutReturnType_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_2")) return false; while (true) { - int c = current_position_(b); - if (!getterDeclarationWithoutReturnType_2_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "getterDeclarationWithoutReturnType_2", c)) break; + int pos_ = current_position_(builder_); + if (!getterDeclarationWithoutReturnType_2_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "getterDeclarationWithoutReturnType_2", pos_)) break; } return true; } // 'external' | 'static' - private static boolean getterDeclarationWithoutReturnType_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_2_0")) return false; - boolean r; - r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, STATIC); - return r; + private static boolean getterDeclarationWithoutReturnType_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_2_0")) return false; + boolean result_; + result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, STATIC); + return result_; } // formalParameterList? - private static boolean getterDeclarationWithoutReturnType_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_5")) return false; - formalParameterList(b, l + 1); + private static boolean getterDeclarationWithoutReturnType_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_5")) return false; + formalParameterList(builder_, level_ + 1); return true; } // ';' | functionBodyOrNative - private static boolean getterDeclarationWithoutReturnType_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_6")) return false; - boolean r; - r = consumeToken(b, SEMICOLON); - if (!r) r = functionBodyOrNative(b, l + 1); - return r; + private static boolean getterDeclarationWithoutReturnType_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterDeclarationWithoutReturnType_6")) return false; + boolean result_; + result_ = consumeToken(builder_, SEMICOLON); + if (!result_) result_ = functionBodyOrNative(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // getterDeclaration | setterDeclaration - static boolean getterOrSetterDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "getterOrSetterDeclaration")) return false; - boolean r; - r = getterDeclaration(b, l + 1); - if (!r) r = setterDeclaration(b, l + 1); - return r; + static boolean getterOrSetterDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "getterOrSetterDeclaration")) return false; + boolean result_; + result_ = getterDeclaration(builder_, level_ + 1); + if (!result_) result_ = setterDeclaration(builder_, level_ + 1); + return result_; } /* ********************************************************** */ // constantPattern 'when' expression | // to capture "case a when b:..." // pattern ('when' expression)? - static boolean guardedPattern(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "guardedPattern")) return false; - boolean r; - Marker m = enter_section_(b); - r = guardedPattern_0(b, l + 1); - if (!r) r = guardedPattern_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean guardedPattern(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "guardedPattern")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = guardedPattern_0(builder_, level_ + 1); + if (!result_) result_ = guardedPattern_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // constantPattern 'when' expression - private static boolean guardedPattern_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "guardedPattern_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = constantPattern(b, l + 1); - r = r && consumeToken(b, WHEN); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean guardedPattern_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "guardedPattern_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = constantPattern(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, WHEN); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // pattern ('when' expression)? - private static boolean guardedPattern_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "guardedPattern_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = pattern(b, l + 1); - r = r && guardedPattern_1_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean guardedPattern_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "guardedPattern_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = pattern(builder_, level_ + 1); + result_ = result_ && guardedPattern_1_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ('when' expression)? - private static boolean guardedPattern_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "guardedPattern_1_1")) return false; - guardedPattern_1_1_0(b, l + 1); + private static boolean guardedPattern_1_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "guardedPattern_1_1")) return false; + guardedPattern_1_1_0(builder_, level_ + 1); return true; } // 'when' expression - private static boolean guardedPattern_1_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "guardedPattern_1_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, WHEN); - r = r && expression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean guardedPattern_1_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "guardedPattern_1_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, WHEN); + result_ = result_ && expression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'hide' libraryReferenceList - public static boolean hideCombinator(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "hideCombinator")) return false; - if (!nextTokenIs(b, HIDE)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, HIDE_COMBINATOR, null); - r = consumeToken(b, HIDE); - p = r; // pin = 1 - r = r && libraryReferenceList(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean hideCombinator(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "hideCombinator")) return false; + if (!nextTokenIs(builder_, HIDE)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, HIDE_COMBINATOR, null); + result_ = consumeToken(builder_, HIDE); + pinned_ = result_; // pin = 1 + result_ = result_ && libraryReferenceList(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // IDENTIFIER - public static boolean id(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "id")) return false; - if (!nextTokenIs(b, IDENTIFIER)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, IDENTIFIER); - exit_section_(b, m, ID, r); - return r; + public static boolean id(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "id")) return false; + if (!nextTokenIs(builder_, IDENTIFIER)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, IDENTIFIER); + exit_section_(builder_, marker_, ID, result_); + return result_; } /* ********************************************************** */ // referenceExpression - public static boolean identifierPattern(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "identifierPattern")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, IDENTIFIER_PATTERN, ""); - r = referenceExpression(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean identifierPattern(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "identifierPattern")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, IDENTIFIER_PATTERN, ""); + result_ = referenceExpression(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // 'if' '(' ifExpressionWithRecoverUntilParen ')' element ('else' element)? - public static boolean ifElement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifElement")) return false; - if (!nextTokenIs(b, IF)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, IF_ELEMENT, null); - r = consumeTokens(b, 1, IF, LPAREN); - p = r; // pin = 1 - r = r && report_error_(b, ifExpressionWithRecoverUntilParen(b, l + 1)); - r = p && report_error_(b, consumeToken(b, RPAREN)) && r; - r = p && report_error_(b, element(b, l + 1)) && r; - r = p && ifElement_5(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean ifElement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifElement")) return false; + if (!nextTokenIs(builder_, IF)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, IF_ELEMENT, null); + result_ = consumeTokens(builder_, 1, IF, LPAREN); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, ifExpressionWithRecoverUntilParen(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, consumeToken(builder_, RPAREN)) && result_; + result_ = pinned_ && report_error_(builder_, element(builder_, level_ + 1)) && result_; + result_ = pinned_ && ifElement_5(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // ('else' element)? - private static boolean ifElement_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifElement_5")) return false; - ifElement_5_0(b, l + 1); + private static boolean ifElement_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifElement_5")) return false; + ifElement_5_0(builder_, level_ + 1); return true; } // 'else' element - private static boolean ifElement_5_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifElement_5_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, ELSE); - r = r && element(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean ifElement_5_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifElement_5_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, ELSE); + result_ = result_ && element(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // expression ('case' guardedPattern)? - static boolean ifExpressionWithRecoverUntilParen(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifExpressionWithRecoverUntilParen")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_); - r = expression(b, l + 1); - r = r && ifExpressionWithRecoverUntilParen_1(b, l + 1); - exit_section_(b, l, m, r, false, DartParser::not_paren_recover); - return r; + static boolean ifExpressionWithRecoverUntilParen(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifExpressionWithRecoverUntilParen")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_); + result_ = expression(builder_, level_ + 1); + result_ = result_ && ifExpressionWithRecoverUntilParen_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, DartParser::not_paren_recover); + return result_; } // ('case' guardedPattern)? - private static boolean ifExpressionWithRecoverUntilParen_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifExpressionWithRecoverUntilParen_1")) return false; - ifExpressionWithRecoverUntilParen_1_0(b, l + 1); + private static boolean ifExpressionWithRecoverUntilParen_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifExpressionWithRecoverUntilParen_1")) return false; + ifExpressionWithRecoverUntilParen_1_0(builder_, level_ + 1); return true; } // 'case' guardedPattern - private static boolean ifExpressionWithRecoverUntilParen_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifExpressionWithRecoverUntilParen_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, CASE); - r = r && guardedPattern(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean ifExpressionWithRecoverUntilParen_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifExpressionWithRecoverUntilParen_1_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, CASE); + result_ = result_ && guardedPattern(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // '??' logicOrExpressionWrapper - public static boolean ifNullExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifNullExpression")) return false; - if (!nextTokenIs(b, QUEST_QUEST)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, IF_NULL_EXPRESSION, null); - r = consumeToken(b, QUEST_QUEST); - r = r && logicOrExpressionWrapper(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean ifNullExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifNullExpression")) return false; + if (!nextTokenIs(builder_, QUEST_QUEST)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, IF_NULL_EXPRESSION, null); + result_ = consumeToken(builder_, QUEST_QUEST); + result_ = result_ && logicOrExpressionWrapper(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } /* ********************************************************** */ // logicOrExpressionWrapper ifNullExpression* - static boolean ifNullExpressionWrapper(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifNullExpressionWrapper")) return false; - boolean r; - Marker m = enter_section_(b); - r = logicOrExpressionWrapper(b, l + 1); - r = r && ifNullExpressionWrapper_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean ifNullExpressionWrapper(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifNullExpressionWrapper")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = logicOrExpressionWrapper(builder_, level_ + 1); + result_ = result_ && ifNullExpressionWrapper_1(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ifNullExpression* - private static boolean ifNullExpressionWrapper_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifNullExpressionWrapper_1")) return false; + private static boolean ifNullExpressionWrapper_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifNullExpressionWrapper_1")) return false; while (true) { - int c = current_position_(b); - if (!ifNullExpression(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "ifNullExpressionWrapper_1", c)) break; + int pos_ = current_position_(builder_); + if (!ifNullExpression(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "ifNullExpressionWrapper_1", pos_)) break; } return true; } /* ********************************************************** */ // 'if' '(' ifExpressionWithRecoverUntilParen ')' statement ('else' statement)? - public static boolean ifStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifStatement")) return false; - if (!nextTokenIs(b, IF)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, IF_STATEMENT, null); - r = consumeTokens(b, 1, IF, LPAREN); - p = r; // pin = 1 - r = r && report_error_(b, ifExpressionWithRecoverUntilParen(b, l + 1)); - r = p && report_error_(b, consumeToken(b, RPAREN)) && r; - r = p && report_error_(b, statement(b, l + 1)) && r; - r = p && ifStatement_5(b, l + 1) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean ifStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifStatement")) return false; + if (!nextTokenIs(builder_, IF)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, IF_STATEMENT, null); + result_ = consumeTokens(builder_, 1, IF, LPAREN); + pinned_ = result_; // pin = 1 + result_ = result_ && report_error_(builder_, ifExpressionWithRecoverUntilParen(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, consumeToken(builder_, RPAREN)) && result_; + result_ = pinned_ && report_error_(builder_, statement(builder_, level_ + 1)) && result_; + result_ = pinned_ && ifStatement_5(builder_, level_ + 1) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // ('else' statement)? - private static boolean ifStatement_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifStatement_5")) return false; - ifStatement_5_0(b, l + 1); + private static boolean ifStatement_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifStatement_5")) return false; + ifStatement_5_0(builder_, level_ + 1); return true; } // 'else' statement - private static boolean ifStatement_5_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "ifStatement_5_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, ELSE); - r = r && statement(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean ifStatement_5_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "ifStatement_5_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, ELSE); + result_ = result_ && statement(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'if' '(' dottedName ('==' stringLiteralExpression)? ')' stringLiteralExpression - static boolean importConfig(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importConfig")) return false; - if (!nextTokenIs(b, IF)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeTokens(b, 0, IF, LPAREN); - r = r && dottedName(b, l + 1); - r = r && importConfig_3(b, l + 1); - r = r && consumeToken(b, RPAREN); - r = r && stringLiteralExpression(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean importConfig(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importConfig")) return false; + if (!nextTokenIs(builder_, IF)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeTokens(builder_, 0, IF, LPAREN); + result_ = result_ && dottedName(builder_, level_ + 1); + result_ = result_ && importConfig_3(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, RPAREN); + result_ = result_ && stringLiteralExpression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // ('==' stringLiteralExpression)? - private static boolean importConfig_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importConfig_3")) return false; - importConfig_3_0(b, l + 1); + private static boolean importConfig_3(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importConfig_3")) return false; + importConfig_3_0(builder_, level_ + 1); return true; } // '==' stringLiteralExpression - private static boolean importConfig_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importConfig_3_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, EQ_EQ); - r = r && stringLiteralExpression(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean importConfig_3_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importConfig_3_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, EQ_EQ); + result_ = result_ && stringLiteralExpression(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // metadata* 'import' 'augment'? uriElement importConfig* ('deferred'? 'as' componentName )? combinator* ';' - public static boolean importStatement(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement")) return false; - if (!nextTokenIs(b, "", AT, IMPORT)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, IMPORT_STATEMENT, ""); - r = importStatement_0(b, l + 1); - r = r && consumeToken(b, IMPORT); - r = r && importStatement_2(b, l + 1); - r = r && uriElement(b, l + 1); - p = r; // pin = 4 - r = r && report_error_(b, importStatement_4(b, l + 1)); - r = p && report_error_(b, importStatement_5(b, l + 1)) && r; - r = p && report_error_(b, importStatement_6(b, l + 1)) && r; - r = p && consumeToken(b, SEMICOLON) && r; - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean importStatement(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement")) return false; + if (!nextTokenIs(builder_, "", AT, IMPORT)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, IMPORT_STATEMENT, ""); + result_ = importStatement_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, IMPORT); + result_ = result_ && importStatement_2(builder_, level_ + 1); + result_ = result_ && uriElement(builder_, level_ + 1); + pinned_ = result_; // pin = 4 + result_ = result_ && report_error_(builder_, importStatement_4(builder_, level_ + 1)); + result_ = pinned_ && report_error_(builder_, importStatement_5(builder_, level_ + 1)) && result_; + result_ = pinned_ && report_error_(builder_, importStatement_6(builder_, level_ + 1)) && result_; + result_ = pinned_ && consumeToken(builder_, SEMICOLON) && result_; + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } // metadata* - private static boolean importStatement_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_0")) return false; + private static boolean importStatement_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "importStatement_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "importStatement_0", pos_)) break; } return true; } // 'augment'? - private static boolean importStatement_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_2")) return false; - consumeToken(b, AUGMENT); + private static boolean importStatement_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_2")) return false; + consumeToken(builder_, AUGMENT); return true; } // importConfig* - private static boolean importStatement_4(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_4")) return false; + private static boolean importStatement_4(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_4")) return false; while (true) { - int c = current_position_(b); - if (!importConfig(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "importStatement_4", c)) break; + int pos_ = current_position_(builder_); + if (!importConfig(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "importStatement_4", pos_)) break; } return true; } // ('deferred'? 'as' componentName )? - private static boolean importStatement_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_5")) return false; - importStatement_5_0(b, l + 1); + private static boolean importStatement_5(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_5")) return false; + importStatement_5_0(builder_, level_ + 1); return true; } // 'deferred'? 'as' componentName - private static boolean importStatement_5_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_5_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = importStatement_5_0_0(b, l + 1); - r = r && consumeToken(b, AS); - r = r && componentName(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean importStatement_5_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_5_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = importStatement_5_0_0(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, AS); + result_ = result_ && componentName(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // 'deferred'? - private static boolean importStatement_5_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_5_0_0")) return false; - consumeToken(b, DEFERRED); + private static boolean importStatement_5_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_5_0_0")) return false; + consumeToken(builder_, DEFERRED); return true; } // combinator* - private static boolean importStatement_6(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "importStatement_6")) return false; + private static boolean importStatement_6(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "importStatement_6")) return false; while (true) { - int c = current_position_(b); - if (!combinator(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "importStatement_6", c)) break; + int pos_ = current_position_(builder_); + if (!combinator(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "importStatement_6", pos_)) break; } return true; } /* ********************************************************** */ // metadata* ('external' | 'static' | 'final' | 'const' | 'covariant')* type | metadata+ - public static boolean incompleteDeclaration(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, INCOMPLETE_DECLARATION, ""); - r = incompleteDeclaration_0(b, l + 1); - if (!r) r = incompleteDeclaration_1(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean incompleteDeclaration(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, INCOMPLETE_DECLARATION, ""); + result_ = incompleteDeclaration_0(builder_, level_ + 1); + if (!result_) result_ = incompleteDeclaration_1(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // metadata* ('external' | 'static' | 'final' | 'const' | 'covariant')* type - private static boolean incompleteDeclaration_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = incompleteDeclaration_0_0(b, l + 1); - r = r && incompleteDeclaration_0_1(b, l + 1); - r = r && type(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean incompleteDeclaration_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = incompleteDeclaration_0_0(builder_, level_ + 1); + result_ = result_ && incompleteDeclaration_0_1(builder_, level_ + 1); + result_ = result_ && type(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // metadata* - private static boolean incompleteDeclaration_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration_0_0")) return false; + private static boolean incompleteDeclaration_0_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration_0_0")) return false; while (true) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "incompleteDeclaration_0_0", c)) break; + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "incompleteDeclaration_0_0", pos_)) break; } return true; } // ('external' | 'static' | 'final' | 'const' | 'covariant')* - private static boolean incompleteDeclaration_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration_0_1")) return false; + private static boolean incompleteDeclaration_0_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration_0_1")) return false; while (true) { - int c = current_position_(b); - if (!incompleteDeclaration_0_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "incompleteDeclaration_0_1", c)) break; + int pos_ = current_position_(builder_); + if (!incompleteDeclaration_0_1_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "incompleteDeclaration_0_1", pos_)) break; } return true; } // 'external' | 'static' | 'final' | 'const' | 'covariant' - private static boolean incompleteDeclaration_0_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration_0_1_0")) return false; - boolean r; - r = consumeToken(b, EXTERNAL); - if (!r) r = consumeToken(b, STATIC); - if (!r) r = consumeToken(b, FINAL); - if (!r) r = consumeToken(b, CONST); - if (!r) r = consumeToken(b, COVARIANT); - return r; + private static boolean incompleteDeclaration_0_1_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration_0_1_0")) return false; + boolean result_; + result_ = consumeToken(builder_, EXTERNAL); + if (!result_) result_ = consumeToken(builder_, STATIC); + if (!result_) result_ = consumeToken(builder_, FINAL); + if (!result_) result_ = consumeToken(builder_, CONST); + if (!result_) result_ = consumeToken(builder_, COVARIANT); + return result_; } // metadata+ - private static boolean incompleteDeclaration_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incompleteDeclaration_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = metadata(b, l + 1); - while (r) { - int c = current_position_(b); - if (!metadata(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "incompleteDeclaration_1", c)) break; + private static boolean incompleteDeclaration_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incompleteDeclaration_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = metadata(builder_, level_ + 1); + while (result_) { + int pos_ = current_position_(builder_); + if (!metadata(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "incompleteDeclaration_1", pos_)) break; } - exit_section_(b, m, null, r); - return r; + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // '<' + <> + '>' <> - static boolean incorrectNormalFormalParameter(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incorrectNormalFormalParameter")) return false; - if (!nextTokenIs(b, LT)) return false; - boolean r; - Marker m = enter_section_(b); - r = incorrectNormalFormalParameter_0(b, l + 1); - r = r && incorrectNormalFormalParameter_1(b, l + 1); - r = r && consumeToken(b, GT); - r = r && nonStrictID(b, l + 1); - exit_section_(b, m, null, r); - return r; + static boolean incorrectNormalFormalParameter(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incorrectNormalFormalParameter")) return false; + if (!nextTokenIs(builder_, LT)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = incorrectNormalFormalParameter_0(builder_, level_ + 1); + result_ = result_ && incorrectNormalFormalParameter_1(builder_, level_ + 1); + result_ = result_ && consumeToken(builder_, GT); + result_ = result_ && nonStrictID(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } // '<' + - private static boolean incorrectNormalFormalParameter_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incorrectNormalFormalParameter_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, LT); - while (r) { - int c = current_position_(b); - if (!consumeToken(b, LT)) break; - if (!empty_element_parsed_guard_(b, "incorrectNormalFormalParameter_0", c)) break; + private static boolean incorrectNormalFormalParameter_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incorrectNormalFormalParameter_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, LT); + while (result_) { + int pos_ = current_position_(builder_); + if (!consumeToken(builder_, LT)) break; + if (!empty_element_parsed_guard_(builder_, "incorrectNormalFormalParameter_0", pos_)) break; } - exit_section_(b, m, null, r); - return r; + exit_section_(builder_, marker_, null, result_); + return result_; } // <> + - private static boolean incorrectNormalFormalParameter_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "incorrectNormalFormalParameter_1")) return false; - boolean r; - Marker m = enter_section_(b); - r = nonStrictID(b, l + 1); - while (r) { - int c = current_position_(b); - if (!nonStrictID(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "incorrectNormalFormalParameter_1", c)) break; + private static boolean incorrectNormalFormalParameter_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "incorrectNormalFormalParameter_1")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = nonStrictID(builder_, level_ + 1); + while (result_) { + int pos_ = current_position_(builder_); + if (!nonStrictID(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "incorrectNormalFormalParameter_1", pos_)) break; } - exit_section_(b, m, null, r); - return r; + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // ':' superCallOrFieldInitializer (',' superCallOrFieldInitializer)* - public static boolean initializers(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "initializers")) return false; - if (!nextTokenIs(b, COLON)) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COLON); - r = r && superCallOrFieldInitializer(b, l + 1); - r = r && initializers_2(b, l + 1); - exit_section_(b, m, INITIALIZERS, r); - return r; + public static boolean initializers(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "initializers")) return false; + if (!nextTokenIs(builder_, COLON)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COLON); + result_ = result_ && superCallOrFieldInitializer(builder_, level_ + 1); + result_ = result_ && initializers_2(builder_, level_ + 1); + exit_section_(builder_, marker_, INITIALIZERS, result_); + return result_; } // (',' superCallOrFieldInitializer)* - private static boolean initializers_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "initializers_2")) return false; + private static boolean initializers_2(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "initializers_2")) return false; while (true) { - int c = current_position_(b); - if (!initializers_2_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "initializers_2", c)) break; + int pos_ = current_position_(builder_); + if (!initializers_2_0(builder_, level_ + 1)) break; + if (!empty_element_parsed_guard_(builder_, "initializers_2", pos_)) break; } return true; } // ',' superCallOrFieldInitializer - private static boolean initializers_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "initializers_2_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - r = r && superCallOrFieldInitializer(b, l + 1); - exit_section_(b, m, null, r); - return r; + private static boolean initializers_2_0(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "initializers_2_0")) return false; + boolean result_; + Marker marker_ = enter_section_(builder_); + result_ = consumeToken(builder_, COMMA); + result_ = result_ && superCallOrFieldInitializer(builder_, level_ + 1); + exit_section_(builder_, marker_, null, result_); + return result_; } /* ********************************************************** */ // 'implements' typeList - public static boolean interfaces(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "interfaces")) return false; - if (!nextTokenIs(b, IMPLEMENTS)) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, INTERFACES, null); - r = consumeToken(b, IMPLEMENTS); - p = r; // pin = 1 - r = r && typeList(b, l + 1); - exit_section_(b, l, m, r, p, null); - return r || p; + public static boolean interfaces(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "interfaces")) return false; + if (!nextTokenIs(builder_, IMPLEMENTS)) return false; + boolean result_, pinned_; + Marker marker_ = enter_section_(builder_, level_, _NONE_, INTERFACES, null); + result_ = consumeToken(builder_, IMPLEMENTS); + pinned_ = result_; // pin = 1 + result_ = result_ && typeList(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, pinned_, null); + return result_ || pinned_; } /* ********************************************************** */ // 'is' '!'? type - public static boolean isExpression(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "isExpression")) return false; - if (!nextTokenIs(b, IS)) return false; - boolean r; - Marker m = enter_section_(b, l, _LEFT_, IS_EXPRESSION, null); - r = consumeToken(b, IS); - r = r && isExpression_1(b, l + 1); - r = r && type(b, l + 1); - exit_section_(b, l, m, r, false, null); - return r; + public static boolean isExpression(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "isExpression")) return false; + if (!nextTokenIs(builder_, IS)) return false; + boolean result_; + Marker marker_ = enter_section_(builder_, level_, _LEFT_, IS_EXPRESSION, null); + result_ = consumeToken(builder_, IS); + result_ = result_ && isExpression_1(builder_, level_ + 1); + result_ = result_ && type(builder_, level_ + 1); + exit_section_(builder_, level_, marker_, result_, false, null); + return result_; } // '!'? - private static boolean isExpression_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "isExpression_1")) return false; - consumeToken(b, NOT); + private static boolean isExpression_1(PsiBuilder builder_, int level_) { + if (!recursion_guard_(builder_, level_, "isExpression_1")) return false; + consumeToken(builder_, NOT); return true; } /* ********************************************************** */ // componentName ':' - public static boolean label(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "label")) return false; - boolean r; - Marker m = enter_section_(b, l, _NONE_, LABEL, "