jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/parser/JavacParser.java

-:5c956be64b9e
+:71f35e4b93a5
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 /** The name table. */
 private Names names;
 /** End position mappings container */
 private final AbstractEndPosTable endPosTable;
+// Because of javac's limited lookahead, some contexts are ambiguous in
+// the presence of type annotations even though they are not ambiguous
+// in the absence of type annotations.  Consider this code:
+//   void m(String [] m) { }
+//   void m(String ... m) { }
+// After parsing "String", javac calls bracketsOpt which immediately
+// returns if the next character is not '['.  Similarly, javac can see
+// if the next token is ... and in that case parse an ellipsis.  But in
+// the presence of type annotations:
+//   void m(String @A [] m) { }
+//   void m(String @A ... m) { }
+// no finite lookahead is enough to determine whether to read array
+// levels or an ellipsis.  Furthermore, if you call bracketsOpt, then
+// bracketsOpt first reads all the leading annotations and only then
+// discovers that it needs to fail.  bracketsOpt needs a way to push
+// back the extra annotations that it read.  (But, bracketsOpt should
+// not *always* be allowed to push back extra annotations that it finds
+// -- in most contexts, any such extra annotation is an error.
+//
+// The following two variables permit type annotations that have
+// already been read to be stored for later use.  Alternate
+// implementations are possible but would cause much larger changes to
+// the parser.
+/** Type annotations that have already been read but have not yet been used. **/
+private List<JCAnnotation> typeAnnotationsPushedBack = List.nil();
+/**
+* If the parser notices extra annotations, then it either immediately
+* issues an error (if this variable is false) or places the extra
+* annotations in variable typeAnnotationsPushedBack (if this variable
+* is true).
+*/
+private boolean permitTypeAnnotationsPushBack = false;
 interface ErrorRecoveryAction {
 JCTree doRecover(JavacParser parser);
 }
 this.allowLambda = source.allowLambda();
 this.allowMethodReferences = source.allowMethodReferences();
 this.allowDefaultMethods = source.allowDefaultMethods();
 this.allowStaticInterfaceMethods = source.allowStaticInterfaceMethods();
 this.allowIntersectionTypesInCast = source.allowIntersectionTypesInCast();
+this.allowTypeAnnotations = source.allowTypeAnnotations();
 this.keepDocComments = keepDocComments;
 docComments = newDocCommentTable(keepDocComments, fac);
 this.keepLineMap = keepLineMap;
 this.errorTree = F.Erroneous();
 endPosTable = newEndPosTable(keepEndPositions);
 boolean keepDocComments;
 /** Switch: should we keep line table?
 */
 boolean keepLineMap;
+/** Switch: should we recognize type annotations?
+*/
+boolean allowTypeAnnotations;
+/** Switch: is "this" allowed as an identifier?
+* This is needed to parse receiver types.
+*/
+boolean allowThisIdent;
+/** The type of the method receiver, as specified by a first "this" parameter.
+*/
+JCVariableDecl receiverParam;
 /** When terms are parsed, the mode determines which is expected:
 *     mode = EXPR        : an expression
 *     mode = TYPE        : a type
 *     mode = NOPARAMS    : no parameters allowed for type
 warning(token.pos, "enum.as.identifier");
 Name name = token.name();
 nextToken();
 return name;
 }
+} else if (token.kind == THIS) {
+if (allowThisIdent) {
+// Make sure we're using a supported source version.
+checkTypeAnnotations();
+Name name = token.name();
+nextToken();
+return name;
+} else {
+error(token.pos, "this.as.identifier");
+nextToken();
+return names.error;
+}
 } else if (token.kind == UNDERSCORE) {
 warning(token.pos, "underscore.as.identifier");
 Name name = token.name();
 nextToken();
 return name;
 return names.error;
 }
 }
 /**
-* Qualident = Ident { DOT Ident }
+* Qualident = Ident { DOT [Annotations] Ident }
 */
-public JCExpression qualident() {
+public JCExpression qualident(boolean allowAnnos) {
 JCExpression t = toP(F.at(token.pos).Ident(ident()));
 while (token.kind == DOT) {
 int pos = token.pos;
 nextToken();
+List<JCAnnotation> tyannos = null;
+if (allowAnnos) {
+tyannos = typeAnnotationsOpt();
+}
 t = toP(F.at(pos).Select(t, ident()));
+if (tyannos != null && tyannos.nonEmpty()) {
+t = toP(F.at(tyannos.head.pos).AnnotatedType(tyannos, t));
+}
 }
 return t;
 }
 JCExpression literal(Name prefix) {
 t = F.at(pos).Erroneous();
 storeEnd(t, token.endPos);
 nextToken();
 return t;
 }
 //where
 boolean isZero(String s) {
 char[] cs = s.toCharArray();
 int base = ((cs.length > 1 && Character.toLowerCase(cs[1]) == 'x') ? 16 : 10);
 int i = ((base==16) ? 2 : 0);
 while (i < cs.length && (cs[i] == '0' || cs[i] == '.')) i++;
 */
 public JCExpression parseExpression() {
 return term(EXPR);
 }
+/**
+* parses (optional) type annotations followed by a type. If the
+* annotations are present before the type and are not consumed during array
+* parsing, this method returns a {@link JCAnnotatedType} consisting of
+* these annotations and the underlying type. Otherwise, it returns the
+* underlying type.
+*
+* <p>
+*
+* Note that this method sets {@code mode} to {@code TYPE} first, before
+* parsing annotations.
+*/
 public JCExpression parseType() {
+List<JCAnnotation> annotations = typeAnnotationsOpt();
+return parseType(annotations);
+}
+public JCExpression parseType(List<JCAnnotation> annotations) {
+JCExpression result = unannotatedType();
+if (annotations.nonEmpty()) {
+result = insertAnnotationsToMostInner(result, annotations, false);
+}
+return result;
+}
+public JCExpression unannotatedType() {
 return term(TYPE);
 }
 JCExpression term(int newmode) {
 int prevmode = mode;
 odStackSupply.add(odStack);
 opStackSupply.add(opStack);
 return t;
 }
 //where
 /** Construct a binary or type test node.
 */
 private JCExpression makeOp(int pos,
 TokenKind topOp,
 JCExpression od1,
 *                 | [TypeArguments] THIS [Arguments]
 *                 | [TypeArguments] SUPER SuperSuffix
 *                 | NEW [TypeArguments] Creator
 *                 | "(" Arguments ")" "->" ( Expression | Block )
 *                 | Ident "->" ( Expression | Block )
-*                 | Ident { "." Ident }
+*                 | [Annotations] Ident { "." [Annotations] Ident }
 *                 | Expression3 MemberReferenceSuffix
-*                   [ "[" ( "]" BracketsOpt "." CLASS | Expression "]" )
+*                   [ [Annotations] "[" ( "]" BracketsOpt "." CLASS | Expression "]" )
 *                   | Arguments
 *                   | "." ( CLASS | THIS | [TypeArguments] SUPER Arguments | NEW [TypeArguments] InnerCreator )
 *                   ]
 *                 | BasicType BracketsOpt "." CLASS
 *  }
 if (token.kind == LT) typeArgs = typeArguments(false);
 t = creator(pos, typeArgs);
 typeArgs = null;
 } else return illegal();
 break;
+case MONKEYS_AT:
+// Only annotated cast types are valid
+List<JCAnnotation> typeAnnos = typeAnnotationsOpt();
+if (typeAnnos.isEmpty()) {
+// else there would be no '@'
+throw new AssertionError("Expected type annotations, but found none!");
+}
+JCExpression expr = term3();
+if ((mode & TYPE) == 0) {
+// Type annotations on class literals no longer legal
+if (!expr.hasTag(Tag.SELECT)) {
+return illegal(typeAnnos.head.pos);
+}
+JCFieldAccess sel = (JCFieldAccess)expr;
+if (sel.name != names._class) {
+return illegal();
+} else {
+log.error(token.pos, "no.annotations.on.dot.class");
+return expr;
+}
+} else {
+// Type annotations targeting a cast
+t = insertAnnotationsToMostInner(expr, typeAnnos, false);
+}
+break;
 case UNDERSCORE: case IDENTIFIER: case ASSERT: case ENUM:
 if (typeArgs != null) return illegal();
 if ((mode & EXPR) != 0 && peekToken(ARROW)) {
 t = lambdaExpressionOrStatement(false, false, pos);
 } else {
 t = toP(F.at(token.pos).Ident(ident()));
 loop: while (true) {
 pos = token.pos;
+final List<JCAnnotation> annos = typeAnnotationsOpt();
+// need to report an error later if LBRACKET is for array
+// index access rather than array creation level
+if (!annos.isEmpty() && token.kind != LBRACKET && token.kind != ELLIPSIS)
+return illegal(annos.head.pos);
 switch (token.kind) {
 case LBRACKET:
 nextToken();
 if (token.kind == RBRACKET) {
 nextToken();
 t = bracketsOpt(t);
 t = toP(F.at(pos).TypeArray(t));
-t = bracketsSuffix(t);
+if (annos.nonEmpty()) {
+t = toP(F.at(pos).AnnotatedType(annos, t));
+}
+// .class is only allowed if there were no annotations
+JCExpression nt = bracketsSuffix(t);
+if (nt != t && (annos.nonEmpty() || TreeInfo.containsTypeAnnotation(t))) {
+// t and nt are different if bracketsSuffix parsed a .class.
+// The check for nonEmpty covers the case when the whole array is annotated.
+// Helper method isAnnotated looks for annos deeply within t.
+syntaxError("no.annotations.on.dot.class");
+}
+t = nt;
 } else {
 if ((mode & EXPR) != 0) {
 mode = EXPR;
 JCExpression t1 = term();
+if (!annos.isEmpty()) t = illegal(annos.head.pos);
 t = to(F.at(pos).Indexed(t, t1));
 }
 accept(RBRACKET);
 }
 break loop;
 case LPAREN:
 if ((mode & EXPR) != 0) {
 mode = EXPR;
 t = arguments(typeArgs, t);
+if (!annos.isEmpty()) t = illegal(annos.head.pos);
 typeArgs = null;
 }
 break loop;
 case DOT:
 nextToken();
 t = innerCreator(pos1, typeArgs, t);
 typeArgs = null;
 break loop;
 }
 }
+List<JCAnnotation> tyannos = null;
+if ((mode & TYPE) != 0 && token.kind == MONKEYS_AT) {
+tyannos = typeAnnotationsOpt();
+}
 // typeArgs saved for next loop iteration.
 t = toP(F.at(pos).Select(t, ident()));
+if (tyannos != null && tyannos.nonEmpty()) {
+t = toP(F.at(tyannos.head.pos).AnnotatedType(tyannos, t));
+}
 break;
+case ELLIPSIS:
+if (this.permitTypeAnnotationsPushBack) {
+this.typeAnnotationsPushedBack = annos;
+} else if (annos.nonEmpty()) {
+// Don't return here -- error recovery attempt
+illegal(annos.head.pos);
+}
+break loop;
 case LT:
 if ((mode & TYPE) == 0 && isUnboundMemberRef()) {
 //this is an unbound method reference whose qualifier
 //is a generic type i.e. A<S>::m
 int pos1 = token.pos;
 JCExpression term3Rest(JCExpression t, List<JCExpression> typeArgs) {
 if (typeArgs != null) illegal();
 while (true) {
 int pos1 = token.pos;
+final List<JCAnnotation> annos = typeAnnotationsOpt();
 if (token.kind == LBRACKET) {
 nextToken();
 if ((mode & TYPE) != 0) {
 int oldmode = mode;
 mode = TYPE;
 t = bracketsOpt(t);
 t = toP(F.at(pos1).TypeArray(t));
 if (token.kind == COLCOL) {
 mode = EXPR;
 continue;
+}
+if (annos.nonEmpty()) {
+t = toP(F.at(pos1).AnnotatedType(annos, t));
 }
 return t;
 }
 mode = oldmode;
 }
 nextToken();
 if (token.kind == LT) typeArgs = typeArguments(false);
 t = innerCreator(pos2, typeArgs, t);
 typeArgs = null;
 } else {
+List<JCAnnotation> tyannos = null;
+if ((mode & TYPE) != 0 && token.kind == MONKEYS_AT) {
+// is the mode check needed?
+tyannos = typeAnnotationsOpt();
+}
 t = toP(F.at(pos1).Select(t, ident()));
+if (tyannos != null && tyannos.nonEmpty()) {
+t = toP(F.at(tyannos.head.pos).AnnotatedType(tyannos, t));
+}
 t = argumentsOpt(typeArgs, typeArgumentsOpt(t));
 typeArgs = null;
 }
 } else if ((mode & EXPR) != 0 && token.kind == COLCOL) {
 mode = EXPR;
 if (typeArgs != null) return illegal();
 accept(COLCOL);
 t = memberReferenceSuffix(pos1, t);
 } else {
+if (!annos.isEmpty()) {
+if (permitTypeAnnotationsPushBack)
+typeAnnotationsPushedBack = annos;
+else
+return illegal(annos.head.pos);
+}
 break;
 }
 }
 while ((token.kind == PLUSPLUS || token.kind == SUBSUB) && (mode & EXPR) != 0) {
 mode = EXPR;
 */
 @SuppressWarnings("fallthrough")
 ParensResult analyzeParens() {
 int depth = 0;
 boolean type = false;
-for (int lookahead = 0 ; ; lookahead++) {
+outer: for (int lookahead = 0 ; ; lookahead++) {
 TokenKind tk = S.token(lookahead).kind;
 switch (tk) {
 case EXTENDS: case SUPER: case COMMA:
 type = true;
 case QUES: case DOT: case AMP:
 return ParensResult.IMPLICIT_LAMBDA;
 }
 break;
 case FINAL:
 case ELLIPSIS:
-case MONKEYS_AT:
 //those can only appear in explicit lambdas
 return ParensResult.EXPLICIT_LAMBDA;
+case MONKEYS_AT:
+type = true;
+lookahead += 1; //skip '@'
+while (peekToken(lookahead, DOT)) {
+lookahead += 2;
+}
+if (peekToken(lookahead, LPAREN)) {
+lookahead++;
+//skip annotation values
+int nesting = 0;
+for (; ; lookahead++) {
+TokenKind tk2 = S.token(lookahead).kind;
+switch (tk2) {
+case EOF:
+return ParensResult.PARENS;
+case LPAREN:
+nesting++;
+break;
+case RPAREN:
+nesting--;
+if (nesting == 0) {
+continue outer;
+}
+break;
+}
+}
+}
+break;
 case LBRACKET:
 if (peekToken(lookahead, RBRACKET, LAX_IDENTIFIER)) {
 // '[', ']', Identifier/'_'/'assert'/'enum' -> explicit lambda
 return ParensResult.EXPLICIT_LAMBDA;
 } else if (peekToken(lookahead, RBRACKET, RPAREN) ||
 }
 /**
 *  {@literal
 *  TypeArgument = Type
-*               | "?"
+*               | [Annotations] "?"
-*               | "?" EXTENDS Type {"&" Type}
+*               | [Annotations] "?" EXTENDS Type {"&" Type}
-*               | "?" SUPER Type
+*               | [Annotations] "?" SUPER Type
 *  }
 */
 JCExpression typeArgument() {
-if (token.kind != QUES) return parseType();
+List<JCAnnotation> annotations = typeAnnotationsOpt();
+if (token.kind != QUES) return parseType(annotations);
 int pos = token.pos;
 nextToken();
+JCExpression result;
 if (token.kind == EXTENDS) {
 TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.EXTENDS));
 nextToken();
 JCExpression bound = parseType();
-return F.at(pos).Wildcard(t, bound);
+result = F.at(pos).Wildcard(t, bound);
 } else if (token.kind == SUPER) {
 TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.SUPER));
 nextToken();
 JCExpression bound = parseType();
-return F.at(pos).Wildcard(t, bound);
+result = F.at(pos).Wildcard(t, bound);
 } else if (LAX_IDENTIFIER.accepts(token.kind)) {
 //error recovery
 TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
 JCExpression wc = toP(F.at(pos).Wildcard(t, null));
 JCIdent id = toP(F.at(token.pos).Ident(ident()));
 JCErroneous err = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
 reportSyntaxError(err, "expected3", GT, EXTENDS, SUPER);
-return err;
+result = err;
 } else {
 TypeBoundKind t = toP(F.at(pos).TypeBoundKind(BoundKind.UNBOUND));
-return toP(F.at(pos).Wildcard(t, null));
+result = toP(F.at(pos).Wildcard(t, null));
 }
+if (!annotations.isEmpty()) {
+result = toP(F.at(annotations.head.pos).AnnotatedType(annotations,result));
+}
+return result;
 }
 JCTypeApply typeArguments(JCExpression t, boolean diamondAllowed) {
 int pos = token.pos;
 List<JCExpression> args = typeArguments(diamondAllowed);
 return toP(F.at(pos).TypeApply(t, args));
 }
-/** BracketsOpt = {"[" "]"}
+/**
-*/
+* BracketsOpt = { [Annotations] "[" "]" }*
-private JCExpression bracketsOpt(JCExpression t) {
+*
+* <p>
+*
+* <code>annotations</code> is the list of annotations targeting
+* the expression <code>t</code>.
+*/
+private JCExpression bracketsOpt(JCExpression t,
+List<JCAnnotation> annotations) {
+List<JCAnnotation> nextLevelAnnotations = typeAnnotationsOpt();
 if (token.kind == LBRACKET) {
 int pos = token.pos;
 nextToken();
-t = bracketsOptCont(t, pos);
+t = bracketsOptCont(t, pos, nextLevelAnnotations);
-F.at(pos);
+} else if (!nextLevelAnnotations.isEmpty()) {
+if (permitTypeAnnotationsPushBack) {
+this.typeAnnotationsPushedBack = nextLevelAnnotations;
+} else {
+return illegal(nextLevelAnnotations.head.pos);
+}
+}
+if (!annotations.isEmpty()) {
+t = toP(F.at(token.pos).AnnotatedType(annotations, t));
 }
 return t;
 }
-private JCArrayTypeTree bracketsOptCont(JCExpression t, int pos) {
+/** BracketsOpt = [ "[" "]" { [Annotations] "[" "]"} ]
+*/
+private JCExpression bracketsOpt(JCExpression t) {
+return bracketsOpt(t, List.<JCAnnotation>nil());
+}
+private JCExpression bracketsOptCont(JCExpression t, int pos,
+List<JCAnnotation> annotations) {
 accept(RBRACKET);
 t = bracketsOpt(t);
-return toP(F.at(pos).TypeArray(t));
+t = toP(F.at(pos).TypeArray(t));
+if (annotations.nonEmpty()) {
+t = toP(F.at(pos).AnnotatedType(annotations, t));
+}
+return t;
 }
 /** BracketsSuffixExpr = "." CLASS
 *  BracketsSuffixType =
 */
 int pos = token.pos;
 nextToken();
 accept(CLASS);
 if (token.pos == endPosTable.errorEndPos) {
 // error recovery
-Name name = null;
+Name name;
 if (LAX_IDENTIFIER.accepts(token.kind)) {
 name = token.name();
 nextToken();
 } else {
 name = names.error;
 mode = EXPR;
 List<JCExpression> typeArgs = null;
 if (token.kind == LT) {
 typeArgs = typeArguments(false);
 }
-Name refName = null;
+Name refName;
-ReferenceMode refMode = null;
+ReferenceMode refMode;
 if (token.kind == NEW) {
 refMode = ReferenceMode.NEW;
 refName = names.init;
 nextToken();
 } else {
 refName = ident();
 }
 return toP(F.at(t.getStartPosition()).Reference(refMode, refName, t, typeArgs));
 }
-/** Creator = Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
+/** Creator = [Annotations] Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
 */
 JCExpression creator(int newpos, List<JCExpression> typeArgs) {
+List<JCAnnotation> newAnnotations = typeAnnotationsOpt();
 switch (token.kind) {
 case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT:
 case DOUBLE: case BOOLEAN:
-if (typeArgs == null)
+if (typeArgs == null) {
-return arrayCreatorRest(newpos, basicType());
+if (newAnnotations.isEmpty()) {
+return arrayCreatorRest(newpos, basicType());
+} else {
+return arrayCreatorRest(newpos, toP(F.at(newAnnotations.head.pos).AnnotatedType(newAnnotations, basicType())));
+}
+}
 break;
 default:
 }
-JCExpression t = qualident();
+JCExpression t = qualident(true);
+// handle type annotations for non primitive arrays
+if (newAnnotations.nonEmpty()) {
+t = insertAnnotationsToMostInner(t, newAnnotations, false);
+}
 int oldmode = mode;
 mode = TYPE;
 boolean diamondFound = false;
 int lastTypeargsPos = -1;
 if (token.kind == LT) {
 //cannot select after a diamond
 illegal();
 }
 int pos = token.pos;
 nextToken();
+List<JCAnnotation> tyannos = typeAnnotationsOpt();
 t = toP(F.at(pos).Select(t, ident()));
+if (tyannos != null && tyannos.nonEmpty()) {
+t = toP(F.at(tyannos.head.pos).AnnotatedType(tyannos, t));
+}
 if (token.kind == LT) {
 lastTypeargsPos = token.pos;
 checkGenerics();
 t = typeArguments(t, true);
 diamondFound = (mode & DIAMOND) != 0;
 }
 }
 mode = oldmode;
-if (token.kind == LBRACKET) {
+if (token.kind == LBRACKET || token.kind == MONKEYS_AT) {
 JCExpression e = arrayCreatorRest(newpos, t);
 if (diamondFound) {
 reportSyntaxError(lastTypeargsPos, "cannot.create.array.with.diamond");
 return toP(F.at(newpos).Erroneous(List.of(e)));
 }
 reportSyntaxError(err, "cannot.create.array.with.type.arguments");
 return toP(err);
 }
 return e;
 } else if (token.kind == LPAREN) {
-return classCreatorRest(newpos, null, typeArgs, t);
+JCNewClass newClass = classCreatorRest(newpos, null, typeArgs, t);
+if (newClass.def != null) {
+assert newClass.def.mods.annotations.isEmpty();
+if (newAnnotations.nonEmpty()) {
+newClass.def.mods.pos = earlier(newClass.def.mods.pos, newAnnotations.head.pos);
+newClass.def.mods.annotations = List.convert(JCAnnotation.class, newAnnotations);
+}
+}
+return newClass;
 } else {
 setErrorEndPos(token.pos);
 reportSyntaxError(token.pos, "expected2", LPAREN, LBRACKET);
 t = toP(F.at(newpos).NewClass(null, typeArgs, t, List.<JCExpression>nil(), null));
 return toP(F.at(newpos).Erroneous(List.<JCTree>of(t)));
 }
 }
-/** InnerCreator = Ident [TypeArguments] ClassCreatorRest
+/** InnerCreator = [Annotations] Ident [TypeArguments] ClassCreatorRest
 */
 JCExpression innerCreator(int newpos, List<JCExpression> typeArgs, JCExpression encl) {
+List<JCAnnotation> newAnnotations = typeAnnotationsOpt();
 JCExpression t = toP(F.at(token.pos).Ident(ident()));
+if (newAnnotations.nonEmpty()) {
+t = toP(F.at(newAnnotations.head.pos).AnnotatedType(newAnnotations, t));
+}
 if (token.kind == LT) {
 int oldmode = mode;
 checkGenerics();
 t = typeArguments(t, true);
 mode = oldmode;
 }
 return classCreatorRest(newpos, encl, typeArgs, t);
 }
-/** ArrayCreatorRest = "[" ( "]" BracketsOpt ArrayInitializer
+/** ArrayCreatorRest = [Annotations] "[" ( "]" BracketsOpt ArrayInitializer
-*                         | Expression "]" {"[" Expression "]"} BracketsOpt )
+*                         | Expression "]" {[Annotations]  "[" Expression "]"} BracketsOpt )
 */
 JCExpression arrayCreatorRest(int newpos, JCExpression elemtype) {
+List<JCAnnotation> annos = typeAnnotationsOpt();
 accept(LBRACKET);
 if (token.kind == RBRACKET) {
 accept(RBRACKET);
-elemtype = bracketsOpt(elemtype);
+elemtype = bracketsOpt(elemtype, annos);
 if (token.kind == LBRACE) {
-return arrayInitializer(newpos, elemtype);
+JCNewArray na = (JCNewArray)arrayInitializer(newpos, elemtype);
+if (annos.nonEmpty()) {
+// when an array initializer is present then
+// the parsed annotations should target the
+// new array tree
+// bracketsOpt inserts the annotation in
+// elemtype, and it needs to be corrected
+//
+JCAnnotatedType annotated = (JCAnnotatedType)elemtype;
+assert annotated.annotations == annos;
+na.annotations = annotated.annotations;
+na.elemtype = annotated.underlyingType;
+}
+return na;
 } else {
 JCExpression t = toP(F.at(newpos).NewArray(elemtype, List.<JCExpression>nil(), null));
 return syntaxError(token.pos, List.<JCTree>of(t), "array.dimension.missing");
 }
 } else {
 ListBuffer<JCExpression> dims = new ListBuffer<JCExpression>();
+// maintain array dimension type annotations
+ListBuffer<List<JCAnnotation>> dimAnnotations = ListBuffer.lb();
+dimAnnotations.append(annos);
 dims.append(parseExpression());
 accept(RBRACKET);
-while (token.kind == LBRACKET) {
+while (token.kind == LBRACKET
+|| token.kind == MONKEYS_AT) {
+List<JCAnnotation> maybeDimAnnos = typeAnnotationsOpt();
 int pos = token.pos;
 nextToken();
 if (token.kind == RBRACKET) {
-elemtype = bracketsOptCont(elemtype, pos);
+elemtype = bracketsOptCont(elemtype, pos, maybeDimAnnos);
 } else {
-dims.append(parseExpression());
+if (token.kind == RBRACKET) { // no dimension
-accept(RBRACKET);
+elemtype = bracketsOptCont(elemtype, pos, maybeDimAnnos);
+} else {
+dimAnnotations.append(maybeDimAnnos);
+dims.append(parseExpression());
+accept(RBRACKET);
+}
 }
 }
-return toP(F.at(newpos).NewArray(elemtype, dims.toList(), null));
+JCNewArray na = toP(F.at(newpos).NewArray(elemtype, dims.toList(), null));
+na.dimAnnotations = dimAnnotations.toList();
+return na;
 }
 }
 /** ClassCreatorRest = Arguments [ClassBody]
 */
 S.errPos(errPos);
 return toP(F.Exec(syntaxError(startPos, List.<JCTree>of(stm), key)));
 }
 /** CatchClause     = CATCH "(" FormalParameter ")" Block
+* TODO: the "FormalParameter" is not correct, it uses the special "catchTypes" rule below.
 */
 protected JCCatch catchClause() {
 int pos = token.pos;
 accept(CATCH);
 accept(LPAREN);
 ListBuffer<JCExpression> catchTypes = ListBuffer.lb();
 catchTypes.add(parseType());
 while (token.kind == BAR) {
 checkMulticatch();
 nextToken();
-catchTypes.add(qualident());
+// Instead of qualident this is now parseType.
+// But would that allow too much, e.g. arrays or generics?
+catchTypes.add(parseType());
 }
 return catchTypes.toList();
 }
 /** SwitchBlockStatementGroups = { SwitchBlockStatementGroup }
 parseExpression(),
 new ListBuffer<JCExpressionStatement>()).toList();
 }
 /** AnnotationsOpt = { '@' Annotation }
-*/
+*
-List<JCAnnotation> annotationsOpt() {
+* @param kind Whether to parse an ANNOTATION or TYPE_ANNOTATION
+*/
+List<JCAnnotation> annotationsOpt(Tag kind) {
 if (token.kind != MONKEYS_AT) return List.nil(); // optimization
 ListBuffer<JCAnnotation> buf = new ListBuffer<JCAnnotation>();
+int prevmode = mode;
 while (token.kind == MONKEYS_AT) {
 int pos = token.pos;
 nextToken();
-buf.append(annotation(pos));
+buf.append(annotation(pos, kind));
 }
-return buf.toList();
+lastmode = mode;
+mode = prevmode;
+List<JCAnnotation> annotations = buf.toList();
+return annotations;
+}
+List<JCAnnotation> typeAnnotationsOpt() {
+List<JCAnnotation> annotations = annotationsOpt(Tag.TYPE_ANNOTATION);
+return annotations;
 }
 /** ModifiersOpt = { Modifier }
 *  Modifier = PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL
 *           | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | "@"
 pos = partial.pos;
 }
 if (token.deprecatedFlag()) {
 flags |= Flags.DEPRECATED;
 }
-int lastPos = Position.NOPOS;
+int lastPos;
 loop:
 while (true) {
 long flag;
 switch (token.kind) {
 case PRIVATE     : flag = Flags.PRIVATE; break;
 lastPos = token.pos;
 nextToken();
 if (flag == Flags.ANNOTATION) {
 checkAnnotations();
 if (token.kind != INTERFACE) {
-JCAnnotation ann = annotation(lastPos);
+JCAnnotation ann = annotation(lastPos, Tag.ANNOTATION);
 // if first modifier is an annotation, set pos to annotation's.
 if (flags == 0 && annotations.isEmpty())
 pos = ann.pos;
 annotations.append(ann);
-lastPos = ann.pos;
 flag = 0;
 }
 }
 flags |= flag;
 }
 storeEnd(mods, S.prevToken().endPos);
 return mods;
 }
 /** Annotation              = "@" Qualident [ "(" AnnotationFieldValues ")" ]
+*
 * @param pos position of "@" token
-*/
+* @param kind Whether to parse an ANNOTATION or TYPE_ANNOTATION
-JCAnnotation annotation(int pos) {
+*/
+JCAnnotation annotation(int pos, Tag kind) {
 // accept(AT); // AT consumed by caller
 checkAnnotations();
-JCTree ident = qualident();
+if (kind == Tag.TYPE_ANNOTATION) {
+checkTypeAnnotations();
+}
+JCTree ident = qualident(false);
 List<JCExpression> fieldValues = annotationFieldValuesOpt();
-JCAnnotation ann = F.at(pos).Annotation(ident, fieldValues);
+JCAnnotation ann;
+if (kind == Tag.ANNOTATION) {
+ann = F.at(pos).Annotation(ident, fieldValues);
+} else if (kind == Tag.TYPE_ANNOTATION) {
+ann = F.at(pos).TypeAnnotation(ident, fieldValues);
+} else {
+throw new AssertionError("Unhandled annotation kind: " + kind);
+}
 storeEnd(ann, S.prevToken().endPos);
 return ann;
 }
 List<JCExpression> annotationFieldValuesOpt() {
 int pos;
 switch (token.kind) {
 case MONKEYS_AT:
 pos = token.pos;
 nextToken();
-return annotation(pos);
+return annotation(pos, Tag.ANNOTATION);
 case LBRACE:
 pos = token.pos;
 accept(LBRACE);
 ListBuffer<JCExpression> buf = new ListBuffer<JCExpression>();
 if (token.kind != RBRACE) {
 checkNoMods(mods.flags);
 packageAnnotations = mods.annotations;
 mods = null;
 }
 nextToken();
-pid = qualident();
+pid = qualident(false);
 accept(SEMI);
 }
 ListBuffer<JCTree> defs = new ListBuffer<JCTree>();
 boolean checkForImports = true;
 boolean firstTypeDecl = true;
 int flags = Flags.PUBLIC|Flags.STATIC|Flags.FINAL|Flags.ENUM;
 if (token.deprecatedFlag()) {
 flags |= Flags.DEPRECATED;
 }
 int pos = token.pos;
-List<JCAnnotation> annotations = annotationsOpt();
+List<JCAnnotation> annotations = annotationsOpt(Tag.ANNOTATION);
 JCModifiers mods = F.at(annotations.isEmpty() ? Position.NOPOS : pos).Modifiers(flags, annotations);
 List<JCExpression> typeArgs = typeArgumentsOpt();
 int identPos = token.pos;
 Name name = ident();
 int createPos = token.pos;
 // position of the method in the modifiers.
 if (typarams.nonEmpty() && mods.pos == Position.NOPOS) {
 mods.pos = pos;
 storeEnd(mods, pos);
 }
+List<JCAnnotation> annosAfterParams = annotationsOpt(Tag.ANNOTATION);
 Token tk = token;
 pos = token.pos;
 JCExpression type;
 boolean isVoid = token.kind == VOID;
 if (isVoid) {
+if (annosAfterParams.nonEmpty())
+illegal(annosAfterParams.head.pos);
 type = to(F.at(pos).TypeIdent(TypeTag.VOID));
 nextToken();
 } else {
-type = parseType();
+if (annosAfterParams.nonEmpty()) {
+mods.annotations = mods.annotations.appendList(annosAfterParams);
+if (mods.pos == Position.NOPOS)
+mods.pos = mods.annotations.head.pos;
+}
+// method returns types are un-annotated types
+type = unannotatedType();
 }
 if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) {
 if (isInterface || tk.name() != className)
 error(pos, "invalid.meth.decl.ret.type.req");
 return List.of(methodDeclaratorRest(
 boolean isInterface, boolean isVoid,
 Comment dc) {
 if (isInterface && (mods.flags & Flags.STATIC) != 0) {
 checkStaticInterfaceMethods();
 }
-List<JCVariableDecl> params = formalParameters();
+JCVariableDecl prevReceiverParam = this.receiverParam;
-if (!isVoid) type = bracketsOpt(type);
+try {
-List<JCExpression> thrown = List.nil();
+this.receiverParam = null;
-if (token.kind == THROWS) {
+// Parsing formalParameters sets the receiverParam, if present
-nextToken();
+List<JCVariableDecl> params = formalParameters();
-thrown = qualidentList();
+if (!isVoid) type = bracketsOpt(type);
-}
+List<JCExpression> thrown = List.nil();
-JCBlock body = null;
+if (token.kind == THROWS) {
-JCExpression defaultValue;
+nextToken();
-if (token.kind == LBRACE) {
+thrown = qualidentList();
-body = block();
+}
-defaultValue = null;
+JCBlock body = null;
-} else {
+JCExpression defaultValue;
-if (token.kind == DEFAULT) {
+if (token.kind == LBRACE) {
-accept(DEFAULT);
+body = block();
-defaultValue = annotationValue();
+defaultValue = null;
 } else {
-defaultValue = null;
+if (token.kind == DEFAULT) {
-}
+accept(DEFAULT);
-accept(SEMI);
+defaultValue = annotationValue();
-if (token.pos <= endPosTable.errorEndPos) {
+} else {
-// error recovery
+defaultValue = null;
-skip(false, true, false, false);
-if (token.kind == LBRACE) {
-body = block();
 }
-}
+accept(SEMI);
-}
+if (token.pos <= endPosTable.errorEndPos) {
+// error recovery
-JCMethodDecl result =
+skip(false, true, false, false);
-toP(F.at(pos).MethodDef(mods, name, type, typarams,
+if (token.kind == LBRACE) {
-params, thrown,
+body = block();
-body, defaultValue));
+}
-attach(result, dc);
+}
-return result;
+}
-}
+JCMethodDecl result =
-/** QualidentList = Qualident {"," Qualident}
+toP(F.at(pos).MethodDef(mods, name, type, typarams,
+receiverParam, params, thrown,
+body, defaultValue));
+attach(result, dc);
+return result;
+} finally {
+this.receiverParam = prevReceiverParam;
+}
+}
+/** QualidentList = [Annotations] Qualident {"," [Annotations] Qualident}
 */
 List<JCExpression> qualidentList() {
 ListBuffer<JCExpression> ts = new ListBuffer<JCExpression>();
-ts.append(qualident());
+List<JCAnnotation> typeAnnos = typeAnnotationsOpt();
+if (!typeAnnos.isEmpty())
+ts.append(toP(F.at(typeAnnos.head.pos).AnnotatedType(typeAnnos, qualident(true))));
+else
+ts.append(qualident(true));
 while (token.kind == COMMA) {
 nextToken();
-ts.append(qualident());
+typeAnnos = typeAnnotationsOpt();
+if (!typeAnnos.isEmpty())
+ts.append(toP(F.at(typeAnnos.head.pos).AnnotatedType(typeAnnos, qualident(true))));
+else
+ts.append(qualident(true));
 }
 return ts.toList();
 }
 /**
 }
 }
 /**
 *  {@literal
-*  TypeParameter = TypeVariable [TypeParameterBound]
+*  TypeParameter = [Annotations] TypeVariable [TypeParameterBound]
 *  TypeParameterBound = EXTENDS Type {"&" Type}
 *  TypeVariable = Ident
 *  }
 */
 JCTypeParameter typeParameter() {
 int pos = token.pos;
+List<JCAnnotation> annos = typeAnnotationsOpt();
 Name name = ident();
 ListBuffer<JCExpression> bounds = new ListBuffer<JCExpression>();
 if (token.kind == EXTENDS) {
 nextToken();
 bounds.append(parseType());
 while (token.kind == AMP) {
 nextToken();
 bounds.append(parseType());
 }
 }
-return toP(F.at(pos).TypeParameter(name, bounds.toList()));
+return toP(F.at(pos).TypeParameter(name, bounds.toList(), annos));
 }
 /** FormalParameters = "(" [ FormalParameterList ] ")"
 *  FormalParameterList = [ FormalParameterListNovarargs , ] LastFormalParameter
 *  FormalParameterListNovarargs = [ FormalParameterListNovarargs , ] FormalParameter
 List<JCVariableDecl> formalParameters() {
 return formalParameters(false);
 }
 List<JCVariableDecl> formalParameters(boolean lambdaParameters) {
 ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();
-JCVariableDecl lastParam = null;
+JCVariableDecl lastParam;
 accept(LPAREN);
 if (token.kind != RPAREN) {
-params.append(lastParam = formalParameter(lambdaParameters));
+this.allowThisIdent = true;
+lastParam = formalParameter(lambdaParameters);
+if (lastParam.name.contentEquals(TokenKind.THIS.name)) {
+this.receiverParam = lastParam;
+} else {
+params.append(lastParam);
+}
+this.allowThisIdent = false;
 while ((lastParam.mods.flags & Flags.VARARGS) == 0 && token.kind == COMMA) {
 nextToken();
 params.append(lastParam = formalParameter(lambdaParameters));
 }
 }
 checkNoMods(mods.flags & ~(Flags.FINAL | Flags.DEPRECATED));
 mods.flags |= flags;
 return mods;
 }
+/**
+* Inserts the annotations (and possibly a new array level)
+* to the left-most type in an array or nested type.
+*
+* When parsing a type like {@code @B Outer.Inner @A []}, the
+* {@code @A} annotation should target the array itself, while
+* {@code @B} targets the nested type {@code Outer}.
+*
+* Currently the parser parses the annotation first, then
+* the array, and then inserts the annotation to the left-most
+* nested type.
+*
+* When {@code createNewLevel} is true, then a new array
+* level is inserted as the most inner type, and have the
+* annotations target it.  This is useful in the case of
+* varargs, e.g. {@code String @A [] @B ...}, as the parser
+* first parses the type {@code String @A []} then inserts
+* a new array level with {@code @B} annotation.
+*/
+private JCExpression insertAnnotationsToMostInner(
+JCExpression type, List<JCAnnotation> annos,
+boolean createNewLevel) {
+int origEndPos = getEndPos(type);
+JCExpression mostInnerType = type;
+JCArrayTypeTree mostInnerArrayType = null;
+while (TreeInfo.typeIn(mostInnerType).hasTag(TYPEARRAY)) {
+mostInnerArrayType = (JCArrayTypeTree) TreeInfo.typeIn(mostInnerType);
+mostInnerType = mostInnerArrayType.elemtype;
+}
+if (createNewLevel) {
+mostInnerType = to(F.at(token.pos).TypeArray(mostInnerType));
+}
+JCExpression mostInnerTypeToReturn = mostInnerType;
+if (annos.nonEmpty()) {
+JCExpression lastToModify = mostInnerType;
+while (TreeInfo.typeIn(mostInnerType).hasTag(SELECT) ||
+TreeInfo.typeIn(mostInnerType).hasTag(TYPEAPPLY)) {
+while (TreeInfo.typeIn(mostInnerType).hasTag(SELECT)) {
+lastToModify = mostInnerType;
+mostInnerType = ((JCFieldAccess) TreeInfo.typeIn(mostInnerType)).getExpression();
+}
+while (TreeInfo.typeIn(mostInnerType).hasTag(TYPEAPPLY)) {
+lastToModify = mostInnerType;
+mostInnerType = ((JCTypeApply) TreeInfo.typeIn(mostInnerType)).clazz;
+}
+}
+mostInnerType = F.at(annos.head.pos).AnnotatedType(annos, mostInnerType);
+if (TreeInfo.typeIn(lastToModify).hasTag(TYPEAPPLY)) {
+((JCTypeApply) TreeInfo.typeIn(lastToModify)).clazz = mostInnerType;
+} else if (TreeInfo.typeIn(lastToModify).hasTag(SELECT)) {
+((JCFieldAccess) TreeInfo.typeIn(lastToModify)).selected = mostInnerType;
+} else {
+// We never saw a SELECT or TYPEAPPLY, return the annotated type.
+mostInnerTypeToReturn = mostInnerType;
+}
+}
+if (mostInnerArrayType == null) {
+return mostInnerTypeToReturn;
+} else {
+mostInnerArrayType.elemtype = mostInnerTypeToReturn;
+storeEnd(type, origEndPos);
+return type;
+}
+}
 /** FormalParameter = { FINAL | '@' Annotation } Type VariableDeclaratorId
 *  LastFormalParameter = { FINAL | '@' Annotation } Type '...' Ident | FormalParameter
 */
 protected JCVariableDecl formalParameter() {
 return formalParameter(false);
 }
 protected JCVariableDecl formalParameter(boolean lambdaParameter) {
 JCModifiers mods = optFinal(Flags.PARAMETER);
+// need to distinguish between vararg annos and array annos
+// look at typeAnnotationsPushedBack comment
+this.permitTypeAnnotationsPushBack = true;
 JCExpression type = parseType();
+this.permitTypeAnnotationsPushBack = false;
 if (token.kind == ELLIPSIS) {
+List<JCAnnotation> varargsAnnos = typeAnnotationsPushedBack;
+typeAnnotationsPushedBack = List.nil();
 checkVarargs();
 mods.flags |= Flags.VARARGS;
-type = to(F.at(token.pos).TypeArray(type));
+// insert var arg type annotations
-nextToken();
+type = insertAnnotationsToMostInner(type, varargsAnnos, true);
+nextToken();
+} else {
+// if not a var arg, then typeAnnotationsPushedBack should be null
+if (typeAnnotationsPushedBack.nonEmpty()) {
+reportSyntaxError(typeAnnotationsPushedBack.head.pos,
+"illegal.start.of.type");
+}
+typeAnnotationsPushedBack = List.nil();
 }
 return variableDeclaratorId(mods, type, lambdaParameter);
 }
 protected JCVariableDecl implicitParameter() {
 if (!allowStaticInterfaceMethods) {
 log.error(token.pos, "static.intf.methods.not.supported.in.source", source.name);
 allowStaticInterfaceMethods = true;
 }
 }
+void checkTypeAnnotations() {
+if (!allowTypeAnnotations) {
+log.error(token.pos, "type.annotations.not.supported.in.source", source.name);
+allowTypeAnnotations = true;
+}
+}
 /*
 * a functional source tree and end position mappings
 */
 protected class SimpleEndPosTable extends AbstractEndPosTable {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/parser/JavacParser.java

src/share/classes/com/sun/tools/javac/parser/JavacParser.java