TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr - length];

  boolean hasAbstractMethods = false;

  int enumConstantsCounter = 0;

  for (int i = length - 1; i >= 0; i--) {

    if (astNode instanceof AbstractMethodDeclaration) {

      //methods and constructors have been regrouped into one single list

      flag[i] = 2;

      size2++;

      if (((AbstractMethodDeclaration) astNode).isAbstract()) {

  if (iComment < 0) return false; // no comment available

  int iStatement = this.astLengthPtr;

  if (iStatement < 0 || this.astLengthStack[iStatement] <= 1) return false; // no statement available

  // Fallthrough comment must be located after the previous statement

  int rangeStart = lastNode.sourceEnd;

  previousComment: for (; iComment >= 0; iComment--) {

    int commentStart = this.scanner.commentStarts[iComment];

    if (commentStart < 0) commentStart = -commentStart; // line comments have negative start positions

    // ignore comments before start

  markEnclosingMemberWithLocalOrFunctionalType(LocalTypeKind.LOCAL);

  for (int i = this.astPtr; i >= 0; i--) {

    if (node instanceof AbstractMethodDeclaration

        || node instanceof FieldDeclaration

        || (node instanceof TypeDeclaration // mark type for now: all initializers will be marked when added to this type

            // and enclosing type must not be closed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=147485)

            && ((TypeDeclaration) node).declarationSourceEnd == 0)) {

      switch (context) {

        case METHOD_REFERENCE:

          node.bits |= ASTNode.HasFunctionalInterfaceTypes;

          break;

        case LAMBDA:

          node.bits |= ASTNode.HasFunctionalInterfaceTypes;

          //$FALL-THROUGH$

        case LOCAL:

          node.bits |= ASTNode.HasLocalType;

      }

      return;

    }

  }

  // default to reference context (case of parse method body)

  if (this.referenceContext instanceof AbstractMethodDeclaration

      || this.referenceContext instanceof TypeDeclaration) {

    switch (context) {

      case METHOD_REFERENCE:

        node.bits |= ASTNode.HasFunctionalInterfaceTypes;

        break;

      case LAMBDA:

  boolean containsInitializers = false;

  TypeDeclaration typeDeclaration = null;

  for (int i = 0, max = result.length; i < max; i++) {

    // parse each class body declaration

    if (node instanceof TypeDeclaration) {

      ((TypeDeclaration) node).parseMethods(this, unit);

    } else if (node instanceof AbstractMethodDeclaration) {

      ((AbstractMethodDeclaration) node).parseStatements(this, unit);

    } else if (node instanceof FieldDeclaration) {

        // to compute bodyStart, and thus used to set next checkpoint.

        int count;

        for (count = 0; count < argLength; count++){

          if(aNode instanceof Argument) {

            Argument argument = (Argument)aNode;

            /* cannot be an argument if non final */

            char[][] argTypeName = argument.type.getTypeName();

            if ((argument.modifiers & ~ClassFileConstants.AccFinal) != 0

  block.sourceStart = lastStart;

  element = element.add(block, 1);

  int blockIndex = 1;  // ignore first block start, since manually rebuilt here

  for (int i = 0; i <= this.astPtr; i++, lastNode = node) {

    node = this.astStack[i];

    if(node instanceof ForeachStatement && ((ForeachStatement)node).action == null) {

      node = ((ForeachStatement)node).elementVariable;

    }

         replace those fragments with the fuller statement that provides target type for the lambda that got closed just now. There is prior

         art/precedent in the Java 7 world to this: Search for recoveredBlock.statements[--recoveredBlock.statementCount] = null;

         See also that this concern does not arise in the case of field/local initialization since the initializer is replaced with full tree by consumeExitVariableWithInitialization.

      */

      if (assistNodeParent != null || enclosingNode != null) {

        RecoveredBlock recoveredBlock = (RecoveredBlock) (this.currentElement instanceof RecoveredBlock ? this.currentElement :

                          (this.currentElement.parent instanceof RecoveredBlock) ? this.currentElement.parent : null);

        if (recoveredBlock != null) {

          RecoveredStatement recoveredStatement = recoveredBlock.statementCount > 0 ? recoveredBlock.statements[recoveredBlock.statementCount - 1] : null;

          if (parseTree != null && (parseTree == assistNodeParent || parseTree == enclosingNode)) {

            recoveredBlock.statements[--recoveredBlock.statementCount] = null;

            this.currentElement = recoveredBlock;

          }

        }

  return ((SelectionScanner)this.scanner).selectionIdentifier;

  if (this.isOrphanCompletionNode){

    this.isOrphanCompletionNode = false;

    /* if in context of a type, then persists the identifier into a fake field return type */

    if (this.currentElement instanceof RecoveredType){

      this.currentToken = 0; // given we are not on an eof, we do not want side effects caused by looked-ahead token

  }

}

  int kind = topKnownElementKind(SELECTION_OR_ASSIST_PARSER);

  if(kind != 0) {

    int info = topKnownElementInfo(SELECTION_OR_ASSIST_PARSER);

    nextElement : switch (kind) {

      case K_BETWEEN_CASE_AND_COLON :

        if(this.expressionPtr > 0) {

          SwitchStatement switchStatement = new SwitchStatement();

          switchStatement.expression = this.expressionStack[this.expressionPtr - 1];

          if(this.astLengthPtr > -1 && this.astPtr > -1) {

            int length = this.astLengthStack[this.astLengthPtr];

            int newAstPtr = this.astPtr - length;

            if(length != 0 && firstNode.sourceStart > switchStatement.expression.sourceEnd) {

              switchStatement.statements = new Statement[length + 1];

              System.arraycopy(

                this.astStack,

                newAstPtr + 1,

    try {

      this.hasComputedVisibleElementBindings = true;

 

      Scope scope = this.assistScope;

      boolean notInJavadoc = this.completionContext.javadoc == 0;

 

      this.visibleLocalVariables = new ObjectVector();

      this.visibleFields = new ObjectVector();

      this.visibleMethods = new ObjectVector();