Example #1
0
  /*
   * Update the corresponding parse node from parser state which
   * is about to disappear because of restarting recovery
   */
  public void updateFromParserState() {
    // if parent is null then recovery already occured in diet parser.
    if (this.bodyStartsAtHeaderEnd() && this.parent != null) {
      Parser parser = this.parser();
      /* might want to recover arguments or thrown exceptions */
      if (parser.listLength > 0 && parser.astLengthPtr > 0) { // awaiting interface type references
        /* has consumed the arguments - listed elements must be thrown exceptions */
        if (methodDeclaration.sourceEnd == parser.rParenPos) {

          // protection for bugs 15142
          int length = parser.astLengthStack[parser.astLengthPtr];
          int astPtr = parser.astPtr - length;
          boolean canConsume = astPtr >= 0;
          if (canConsume) {
            if ((!(parser.astStack[astPtr] instanceof AbstractMethodDeclaration))) {
              canConsume = false;
            }
            for (int i = 1, max = length + 1; i < max; i++) {
              if (!(parser.astStack[astPtr + i] instanceof TypeReference)) {
                canConsume = false;
              }
            }
          }
          if (canConsume) {
            parser.consumeMethodHeaderThrowsClause();
            // will reset typeListLength to zero
            // thus this check will only be performed on first errorCheck after void foo() throws X,
            // Y,
          } else {
            parser.listLength = 0;
          }
        } else {
          /* has not consumed arguments yet, listed elements must be arguments */
          if (parser.currentToken == TokenNameLPAREN || parser.currentToken == TokenNameSEMICOLON) {
            /* if currentToken is parenthesis this last argument is a method/field signature */
            parser.astLengthStack[parser.astLengthPtr]--;
            parser.astPtr--;
            parser.listLength--;
            parser.currentToken = 0;
          }
          int argLength = parser.astLengthStack[parser.astLengthPtr];
          int argStart = parser.astPtr - argLength + 1;
          boolean needUpdateRParenPos =
              parser.rParenPos < parser.lParenPos; // 12387 : rParenPos will be used

          // remove unfinished annotation nodes
          MemberValuePair[] memberValuePairs = null;
          while (argLength > 0 && parser.astStack[parser.astPtr] instanceof MemberValuePair) {
            System.arraycopy(
                parser.astStack,
                argStart,
                memberValuePairs = new MemberValuePair[argLength],
                0,
                argLength);
            parser.astLengthPtr--;
            parser.astPtr -= argLength;

            argLength = parser.astLengthStack[parser.astLengthPtr];
            argStart = parser.astPtr - argLength + 1;
            needUpdateRParenPos = true;
          }

          // to compute bodyStart, and thus used to set next checkpoint.
          int count;
          for (count = 0; count < argLength; count++) {
            ASTNode aNode = parser.astStack[argStart + 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
                  || (argTypeName.length == 1
                      && CharOperation.equals(argTypeName[0], TypeBinding.VOID.sourceName()))) {
                parser.astLengthStack[parser.astLengthPtr] = count;
                parser.astPtr = argStart + count - 1;
                parser.listLength = count;
                parser.currentToken = 0;
                break;
              }
              if (needUpdateRParenPos) parser.rParenPos = argument.sourceEnd + 1;
            } else {
              parser.astLengthStack[parser.astLengthPtr] = count;
              parser.astPtr = argStart + count - 1;
              parser.listLength = count;
              parser.currentToken = 0;
              break;
            }
          }
          if (parser.listLength > 0 && parser.astLengthPtr > 0) {

            // protection for bugs 15142
            int length = parser.astLengthStack[parser.astLengthPtr];
            int astPtr = parser.astPtr - length;
            boolean canConsume = astPtr >= 0;
            if (canConsume) {
              if ((!(parser.astStack[astPtr] instanceof AbstractMethodDeclaration))) {
                canConsume = false;
              }
              for (int i = 1, max = length + 1; i < max; i++) {
                if (!(parser.astStack[astPtr + i] instanceof Argument)) {
                  canConsume = false;
                }
              }
            }
            if (canConsume) {
              parser.consumeMethodHeaderRightParen();
              /* fix-up positions, given they were updated against rParenPos, which did not get set */
              if (parser.currentElement
                  == this) { // parameter addition might have added an awaiting (no return type)
                             // method - see 1FVXQZ4 */
                methodDeclaration.sourceEnd =
                    methodDeclaration.arguments[methodDeclaration.arguments.length - 1].sourceEnd;
                methodDeclaration.bodyStart = methodDeclaration.sourceEnd + 1;
                parser.lastCheckPoint = methodDeclaration.bodyStart;
              }
            }
          }

          if (memberValuePairs != null) {
            System.arraycopy(
                memberValuePairs, 0, parser.astStack, parser.astPtr + 1, memberValuePairs.length);
            parser.astPtr += memberValuePairs.length;
            parser.astLengthStack[++parser.astLengthPtr] = memberValuePairs.length;
          }
        }
      }
    }
  }
Example #2
0
  public AbstractMethodDeclaration updatedMethodDeclaration() {
    /* update annotations */
    if (modifiers != 0) {
      this.methodDeclaration.modifiers |= modifiers;
      if (this.modifiersStart < this.methodDeclaration.declarationSourceStart) {
        this.methodDeclaration.declarationSourceStart = modifiersStart;
      }
    }
    /* update annotations */
    if (annotationCount > 0) {
      int existingCount =
          methodDeclaration.annotations == null ? 0 : methodDeclaration.annotations.length;
      Annotation[] annotationReferences = new Annotation[existingCount + annotationCount];
      if (existingCount > 0) {
        System.arraycopy(
            methodDeclaration.annotations, 0, annotationReferences, annotationCount, existingCount);
      }
      for (int i = 0; i < annotationCount; i++) {
        annotationReferences[i] = annotations[i].updatedAnnotationReference();
      }
      methodDeclaration.annotations = annotationReferences;

      int start = this.annotations[0].annotation.sourceStart;
      if (start < this.methodDeclaration.declarationSourceStart) {
        this.methodDeclaration.declarationSourceStart = start;
      }
    }

    if (methodBody != null) {
      Block block = methodBody.updatedBlock();
      if (block != null) {
        methodDeclaration.statements = block.statements;

        if (methodDeclaration.declarationSourceEnd == 0) {
          methodDeclaration.declarationSourceEnd = block.sourceEnd;
          methodDeclaration.bodyEnd = block.sourceEnd;
        }

        /* first statement might be an explict constructor call destinated to a special slot */
        if (methodDeclaration.isConstructor()) {
          ConstructorDeclaration constructor = (ConstructorDeclaration) methodDeclaration;
          if (methodDeclaration.statements != null
              && methodDeclaration.statements[0] instanceof ExplicitConstructorCall) {
            constructor.constructorCall = (ExplicitConstructorCall) methodDeclaration.statements[0];
            int length = methodDeclaration.statements.length;
            System.arraycopy(
                methodDeclaration.statements,
                1,
                (methodDeclaration.statements = new Statement[length - 1]),
                0,
                length - 1);
          }
          if (constructor.constructorCall == null) { // add implicit constructor call
            constructor.constructorCall = SuperReference.implicitSuperConstructorCall();
          }
        }
      }
    } else {
      if (methodDeclaration.declarationSourceEnd == 0) {
        if (methodDeclaration.sourceEnd + 1 == methodDeclaration.bodyStart) {
          // right brace is missing
          methodDeclaration.declarationSourceEnd = methodDeclaration.sourceEnd;
          methodDeclaration.bodyStart = methodDeclaration.sourceEnd;
          methodDeclaration.bodyEnd = methodDeclaration.sourceEnd;
        } else {
          methodDeclaration.declarationSourceEnd = methodDeclaration.bodyStart;
          methodDeclaration.bodyEnd = methodDeclaration.bodyStart;
        }
      }
    }
    if (localTypeCount > 0) methodDeclaration.bits |= ASTNode.HasLocalType;
    return methodDeclaration;
  }