private MethodDecl matchMethod(
     String methodName,
     NodeList<Stmt> stmts,
     GExpansion expansion,
     NodeList<FormalParameter> params) {
   return methodDecl(primitiveType(Primitive.Int), name(methodName))
       .withModifiers(listOf(Modifier.Private))
       .withParams(
           listOf(
                   formalParameter(primitiveType(Primitive.Int))
                       .withId(variableDeclaratorId(LOOKAHEAD)))
               .appendAll(params))
       .withBody(blockStmt().withStmts(stmts))
       .appendLeadingComment(expansion.toString(e -> e.kind != GExpansion.Kind.Action), true);
 }
 private Expr buildLookaheadWithAmountCondition(
     String symbol,
     GExpansion expansion,
     int amount,
     NodeList<FormalParameter> params,
     NodeList<Expr> args) {
   String matchMethodName = "match" + symbol + "_lookahead" + incrementCount(symbol);
   NodeList<Stmt> stmts =
       buildLookaheadWithAmountCondition(
           Collections.singletonList(expansion.location()), 0, amount, params, args);
   stmts = stmts.append(returnStmt().withExpr(FAILED_LOOKAHEAD));
   createMatchMethod(symbol, matchMethodName, expansion, stmts, emptyList());
   return binaryExpr(
       matchMethodCall(matchMethodName, literalExpr(0), emptyList()),
       BinaryOp.NotEqual,
       FAILED_LOOKAHEAD);
 }
 private List<String> firstTerminalsOf(GExpansion expansion) {
   GContinuations c = new GContinuations(expansion.location(), productions, false);
   c.next();
   return c.terminals();
 }
  private Expr createMatchMethodAndCallFor(
      String symbol,
      String namePrefix,
      GExpansion expansion,
      Expr outerLookahead,
      NodeList<FormalParameter> params,
      NodeList<Expr> args,
      boolean memoize) {
    switch (expansion.kind) {
      case LookAhead:
        Expr semanticLookahead = expansion.semanticLookahead;
        if (semanticLookahead != null) {
          if (semanticLookahead.equals(methodInvocationExpr(name("isLambda")))) {
            semanticLookahead =
                methodInvocationExpr(name("isLambda")).withArgs(listOf(outerLookahead));
          } else if (semanticLookahead.equals(methodInvocationExpr(name("isCast")))) {
            semanticLookahead =
                methodInvocationExpr(name("isCast")).withArgs(listOf(outerLookahead));
          }
          return conditionalExpr(semanticLookahead, outerLookahead, FAILED_LOOKAHEAD);
        }
        return null;
      case Sequence:
        {
          int index = memoize ? memoizationIndex++ : -1;

          NodeList<Stmt> stmts = emptyList();
          int count = 0;
          for (GExpansion child : expansion.children) {
            Expr childCall =
                createMatchMethodAndCallFor(
                    symbol,
                    namePrefix + "_" + ++count,
                    child,
                    LOOKAHEAD,
                    params,
                    params.map(p -> p.id().get().name()),
                    false);
            if (childCall == null) continue;
            stmts = stmts.append(expressionStmt(assignExpr(LOOKAHEAD, AssignOp.Normal, childCall)));
            stmts =
                stmts.append(
                    ifStmt(
                        binaryExpr(LOOKAHEAD, BinaryOp.Equal, FAILED_LOOKAHEAD),
                        memoize
                            ? stmt("return memoizeMatch(initialLookahead, " + index + ", -1);")
                                .build()
                            : stmt("return -1;").build()));
          }

          if (memoize) {
            stmts =
                stmts.prependAll(
                    listOf(
                        stmt("int initialLookahead = lookahead;").build(),
                        stmt("int memoizedMatch = memoizedMatch(initialLookahead, " + index + ");")
                            .build(),
                        stmt("if (memoizedMatch > -2) return memoizedMatch;").build()));
          }

          stmts =
              stmts.append(
                  memoize
                      ? stmt("return memoizeMatch(initialLookahead, " + index + ", lookahead);")
                          .build()
                      : stmt("return lookahead;").build());

          createMatchMethod(symbol, namePrefix, expansion, stmts, params);

          return matchMethodCall(namePrefix, outerLookahead, args);
        }
      case Choice:
        {
          NodeList<Stmt> stmts = emptyList();
          stmts =
              stmts.append(
                  expressionStmt(
                      variableDeclarationExpr(
                          localVariableDecl(primitiveType(Primitive.Int))
                              .withVariables(
                                  listOf(
                                      variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));
          int count = 0;
          for (GExpansion child : expansion.children) {
            Expr childCall =
                createMatchMethodAndCallFor(
                    symbol,
                    namePrefix + "_" + ++count,
                    child,
                    LOOKAHEAD,
                    params,
                    params.map(p -> p.id().get().name()),
                    false);
            if (childCall == null) continue;
            stmts =
                stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
            stmts =
                stmts.append(
                    ifStmt(
                        binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
                        returnStmt().withExpr(LOOKAHEAD_NEW)));
          }
          stmts = stmts.append(returnStmt().withExpr(FAILED_LOOKAHEAD));
          createMatchMethod(symbol, namePrefix, expansion, stmts, params);

          return matchMethodCall(namePrefix, outerLookahead, args);
        }
      case ZeroOrOne:
        {
          NodeList<Stmt> stmts = emptyList();
          stmts =
              stmts.append(
                  expressionStmt(
                      variableDeclarationExpr(
                          localVariableDecl(primitiveType(Primitive.Int))
                              .withVariables(
                                  listOf(
                                      variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));

          Expr childCall =
              createMatchMethodAndCallFor(
                  symbol,
                  namePrefix + "_" + 1,
                  GExpansion.sequence(expansion.children),
                  LOOKAHEAD,
                  params,
                  params.map(p -> p.id().get().name()),
                  false);
          stmts =
              stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
          stmts =
              stmts.append(
                  ifStmt(
                      binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
                      returnStmt().withExpr(LOOKAHEAD_NEW)));

          stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
          createMatchMethod(symbol, namePrefix, expansion, stmts, params);

          return matchMethodCall(namePrefix, outerLookahead, args);
        }
      case ZeroOrMore:
        {
          NodeList<Stmt> stmts = emptyList();
          stmts =
              stmts.append(
                  expressionStmt(
                      variableDeclarationExpr(
                          localVariableDecl(primitiveType(Primitive.Int))
                              .withVariables(
                                  listOf(
                                      variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));

          Expr childCall =
              createMatchMethodAndCallFor(
                  symbol,
                  namePrefix + "_" + 1,
                  GExpansion.sequence(expansion.children),
                  LOOKAHEAD,
                  params,
                  params.map(p -> p.id().get().name()),
                  false);
          stmts =
              stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
          stmts =
              stmts.append(
                  whileStmt(
                      binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
                      blockStmt()
                          .withStmts(
                              listOf(
                                  expressionStmt(
                                      assignExpr(LOOKAHEAD, AssignOp.Normal, LOOKAHEAD_NEW)),
                                  expressionStmt(
                                      assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall))))));
          stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
          createMatchMethod(symbol, namePrefix, expansion, stmts, params);

          return matchMethodCall(namePrefix, outerLookahead, args);
        }
      case OneOrMore:
        {
          NodeList<Stmt> stmts = emptyList();
          stmts =
              stmts.append(
                  expressionStmt(
                      variableDeclarationExpr(
                          localVariableDecl(primitiveType(Primitive.Int))
                              .withVariables(
                                  listOf(
                                      variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));

          Expr childCall =
              createMatchMethodAndCallFor(
                  symbol,
                  namePrefix + "_" + 1,
                  GExpansion.sequence(expansion.children),
                  LOOKAHEAD,
                  params,
                  params.map(p -> p.id().get().name()),
                  false);
          stmts =
              stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
          stmts =
              stmts.append(
                  ifStmt(
                      binaryExpr(LOOKAHEAD_NEW, BinaryOp.Equal, FAILED_LOOKAHEAD),
                      returnStmt().withExpr(FAILED_LOOKAHEAD)));
          stmts =
              stmts.append(
                  whileStmt(
                      binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
                      blockStmt()
                          .withStmts(
                              listOf(
                                  expressionStmt(
                                      assignExpr(LOOKAHEAD, AssignOp.Normal, LOOKAHEAD_NEW)),
                                  expressionStmt(
                                      assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall))))));
          stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
          createMatchMethod(symbol, namePrefix, expansion, stmts, params);

          return matchMethodCall(namePrefix, outerLookahead, args);
        }
      case NonTerminal:
        {
          return createMatchMethodAndCallFor(expansion.symbol, outerLookahead, expansion.hints);
        }
      case Terminal:
        {
          return matchCall(expansion.symbol, LOOKAHEAD);
        }
      case Action:
        {
          return null;
        }
      default:
    }
    return null;
  }
  private Expr matchCondition(
      String symbol, GExpansion expansion, NodeList<FormalParameter> params, NodeList<Expr> args) {
    if (expansion.children != null && !expansion.children.isEmpty()) {
      GExpansion firstChild = expansion.children.get(0);
      if (firstChild.kind == GExpansion.Kind.LookAhead) {
        Expr lookaheadCondition = null;

        Expr semanticLookaheadCondition = firstChild.semanticLookahead;
        int amount = firstChild.amount;
        List<GExpansion> children = firstChild.children;
        boolean negativeLookahead = firstChild.negativeLookahead;

        if (semanticLookaheadCondition != null) {
          if (semanticLookaheadCondition.equals(methodInvocationExpr(name("isLambda")))) {
            semanticLookaheadCondition =
                methodInvocationExpr(name("isLambda")).withArgs(listOf(literalExpr(0)));
          } else if (semanticLookaheadCondition.equals(methodInvocationExpr(name("isCast")))) {
            semanticLookaheadCondition =
                methodInvocationExpr(name("isCast")).withArgs(listOf(literalExpr(0)));
          }
          lookaheadCondition =
              negativeLookahead
                  ? unaryExpr(UnaryOp.Not, semanticLookaheadCondition)
                  : semanticLookaheadCondition;
        }
        if (amount != -1) {
          Expr amountLookaheadCondition =
              buildLookaheadWithAmountCondition(symbol, expansion, amount, params, args);
          lookaheadCondition =
              lookaheadCondition == null
                  ? amountLookaheadCondition
                  : binaryExpr(lookaheadCondition, BinaryOp.And, amountLookaheadCondition);
        }
        if (children != null) {
          String matchMethodName = "match" + symbol + "_lookahead" + incrementCount(symbol);
          Expr call =
              createMatchMethodAndCallFor(
                  symbol,
                  matchMethodName,
                  GExpansion.sequence(children),
                  literalExpr(0),
                  params,
                  args,
                  false);
          Expr descriptiveLookaheadCondition =
              binaryExpr(
                  call, negativeLookahead ? BinaryOp.Equal : BinaryOp.NotEqual, literalExpr(-1));

          lookaheadCondition =
              lookaheadCondition == null
                  ? descriptiveLookaheadCondition
                  : binaryExpr(
                      lookaheadCondition,
                      negativeLookahead ? BinaryOp.Or : BinaryOp.And,
                      descriptiveLookaheadCondition);
        }

        return lookaheadCondition;
      }
    }
    return binaryExpr(
        matchCall(firstTerminalsOf(expansion), literalExpr(0)),
        BinaryOp.NotEqual,
        FAILED_LOOKAHEAD);
  }