jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java

equal deleted inserted replaced

-:0dc780b4fcf3
+:a132763160d7
 JCExpression term2Rest(JCExpression t, int minprec) {
 List<JCExpression[]> savedOd = odStackSupply.elems;
 JCExpression[] odStack = newOdStack();
 List<Token[]> savedOp = opStackSupply.elems;
 Token[] opStack = newOpStack();
+List<int[]> savedPos = posStackSupply.elems;
+int[] posStack = newPosStack();
 // optimization, was odStack = new Tree[...]; opStack = new Tree[...];
 int top = 0;
 odStack[0] = t;
 int startPos = S.pos();
 Token topOp = ERROR;
+int topOpPos = Position.NOPOS;
 while (prec(S.token()) >= minprec) {
+posStack[top] = topOpPos;
 opStack[top] = topOp;
 top++;
 topOp = S.token();
-int pos = S.pos();
+topOpPos = S.pos();
 S.nextToken();
-odStack[top] = topOp == INSTANCEOF ? parseType() : term3();
+odStack[top] = (topOp == INSTANCEOF) ? parseType() : term3();
 while (top > 0 && prec(topOp) >= prec(S.token())) {
-odStack[top-1] = makeOp(pos, topOp, odStack[top-1],
+odStack[top-1] = makeOp(topOpPos, topOp, odStack[top-1],
 odStack[top]);
 top--;
 topOp = opStack[top];
+topOpPos = posStack[top];
 }
 }
 assert top == 0;
 t = odStack[0];
 }
 }
 odStackSupply.elems = savedOd; // optimization
 opStackSupply.elems = savedOp; // optimization
+posStackSupply.elems = savedPos; // optimization
 return t;
 }
 //where
 /** Construct a binary or type test node.
 */
 /** optimization: To save allocating a new operand/operator stack
 *  for every binary operation, we use supplys.
 */
 ListBuffer<JCExpression[]> odStackSupply = new ListBuffer<JCExpression[]>();
 ListBuffer<Token[]> opStackSupply = new ListBuffer<Token[]>();
+ListBuffer<int[]> posStackSupply = new ListBuffer<int[]>();
 private JCExpression[] newOdStack() {
 if (odStackSupply.elems == odStackSupply.last)
 odStackSupply.append(new JCExpression[infixPrecedenceLevels + 1]);
 JCExpression[] odStack = odStackSupply.elems.head;
 if (opStackSupply.elems == opStackSupply.last)
 opStackSupply.append(new Token[infixPrecedenceLevels + 1]);
 Token[] opStack = opStackSupply.elems.head;
 opStackSupply.elems = opStackSupply.elems.tail;
 return opStack;
+}
+private int[] newPosStack() {
+if (posStackSupply.elems == posStackSupply.last)
+posStackSupply.append(new int[infixPrecedenceLevels + 1]);
+int[] posStack = posStackSupply.elems.head;
+posStackSupply.elems = posStackSupply.elems.tail;
+return posStack;
 }
 /** Expression3    = PrefixOp Expression3
 *                 | "(" Expr | TypeNoParams ")" Expression3
 *                 | Primary {Selector} {PostfixOp}
 while (S.token() == COMMA) {
 S.nextToken();
 args.append(typeArgument());
 }
 accept(GT);
-t = F.at(pos1).TypeApply(t, args.toList());
+t = toP(F.at(pos1).TypeApply(t, args.toList()));
 checkGenerics();
 while (S.token() == DOT) {
 S.nextToken();
 mode = TYPE;
 t = toP(F.at(S.pos()).Select(t, ident()));
 t = typeArgumentsOpt(t);
 }
 t = bracketsOpt(toP(t));
 } else if ((mode & EXPR) != 0) {
 mode = EXPR;
-t = F.at(pos1).Binary(op, t, term2Rest(t1, TreeInfo.shiftPrec));
+JCExpression e = term2Rest(t1, TreeInfo.shiftPrec);
+t = F.at(pos1).Binary(op, t, e);
 t = termRest(term1Rest(term2Rest(t, TreeInfo.orPrec)));
 } else {
 accept(GT);
 }
 }
 } else return illegal();
 break;
 case SUPER:
 if ((mode & EXPR) != 0) {
 mode = EXPR;
-t = to(superSuffix(typeArgs, F.at(pos).Ident(names._super)));
+t = to(F.at(pos).Ident(names._super));
+t = superSuffix(typeArgs, t);
 typeArgs = null;
 } else return illegal();
 break;
 case INTLITERAL: case LONGLITERAL: case FLOATLITERAL: case DOUBLELITERAL:
 case CHARLITERAL: case STRINGLITERAL:
 if (S.token() != QUES) return parseType(annotations);
 int pos = S.pos();
 S.nextToken();
 JCExpression result;
 if (S.token() == EXTENDS) {
-TypeBoundKind t = to(F.at(S.pos()).TypeBoundKind(BoundKind.EXTENDS));
+TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.EXTENDS));
 S.nextToken();
-result = F.at(pos).Wildcard(t, parseType());
+JCExpression bound = parseType();
+result = F.at(pos).Wildcard(t, bound);
 } else if (S.token() == SUPER) {
-TypeBoundKind t = to(F.at(S.pos()).TypeBoundKind(BoundKind.SUPER));
+TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.SUPER));
 S.nextToken();
-result = F.at(pos).Wildcard(t, parseType());
+JCExpression bound = parseType();
+result = F.at(pos).Wildcard(t, bound);
 } else if (S.token() == IDENTIFIER) {
 //error recovery
 reportSyntaxError(S.prevEndPos(), "expected3",
 GT, EXTENDS, SUPER);
 TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
 JCExpression wc = toP(F.at(pos).Wildcard(t, null));
 JCIdent id = toP(F.at(S.pos()).Ident(ident()));
 result = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
 } else {
-TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
+TypeBoundKind t = toP(F.at(pos).TypeBoundKind(BoundKind.UNBOUND));
 result = toP(F.at(pos).Wildcard(t, null));
 }
 if (!annotations.isEmpty())
 result = toP(F.at(annotations.head.pos).AnnotatedType(annotations,result));
 return result;
 */
 JCModifiers modifiersOpt() {
 return modifiersOpt(null);
 }
 JCModifiers modifiersOpt(JCModifiers partial) {
-long flags = (partial == null) ? 0 : partial.flags;
+long flags;
+ListBuffer<JCAnnotation> annotations = new ListBuffer<JCAnnotation>();
+int pos;
+if (partial == null) {
+flags = 0;
+pos = S.pos();
+} else {
+flags = partial.flags;
+annotations.appendList(partial.annotations);
+pos = partial.pos;
+}
 if (S.deprecatedFlag()) {
 flags |= Flags.DEPRECATED;
 S.resetDeprecatedFlag();
 }
-ListBuffer<JCAnnotation> annotations = new ListBuffer<JCAnnotation>();
-if (partial != null) annotations.appendList(partial.annotations);
-int pos = S.pos();
 int lastPos = Position.NOPOS;
 loop:
 while (true) {
 long flag;
 switch (S.token()) {
 lastPos = S.pos();
 S.nextToken();
 if (flag == Flags.ANNOTATION) {
 checkAnnotations();
 if (S.token() != INTERFACE) {
 JCAnnotation ann = annotation(lastPos, AnnotationKind.DEFAULT_ANNO);
 // 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;
 }
 default: break;
 }
 /* A modifiers tree with no modifier tokens or annotations
 * has no text position. */
-if (flags == 0 && annotations.isEmpty())
+if ((flags & Flags.ModifierFlags) == 0 && annotations.isEmpty())
 pos = Position.NOPOS;
 JCModifiers mods = F.at(pos).Modifiers(flags, annotations.toList());
 if (pos != Position.NOPOS)
 storeEnd(mods, S.prevEndPos());
 mode = EXPR;
 JCExpression t1 = term1();
 if (t1.getTag() == JCTree.IDENT && S.token() == EQ) {
 int pos = S.pos();
 accept(EQ);
-return toP(F.at(pos).Assign(t1, annotationValue()));
+JCExpression v = annotationValue();
+return toP(F.at(pos).Assign(t1, v));
 } else {
 return t1;
 }
 }
 return annotationValue();
 S.nextToken();
 implementing = typeList();
 }
 List<JCTree> defs = enumBody(name);
-JCModifiers newMods =
+mods.flags |= Flags.ENUM;
-F.at(mods.pos).Modifiers(mods.flags|Flags.ENUM, mods.annotations);
 JCClassDecl result = toP(F.at(pos).
-ClassDef(newMods, name, List.<JCTypeParameter>nil(),
+ClassDef(mods, name, List.<JCTypeParameter>nil(),
 null, implementing, defs));
 attach(result, dc);
 return result;
 }
 mods.annotations.isEmpty()) {
 return List.<JCTree>of(block(pos, mods.flags));
 } else {
 pos = S.pos();
 List<JCTypeParameter> typarams = typeParametersOpt();
-// Hack alert:  if there are type arguments but no Modifiers, the start
-// position will be lost unless we set the Modifiers position.  There
-// should be an AST node for type parameters (BugId 5005090).
-if (typarams.length() > 0 && mods.pos == Position.NOPOS) {
-mods.pos = pos;
-}
 List<JCAnnotation> annosAfterParams = annotationsOpt(AnnotationKind.DEFAULT_ANNO);
-Token token = S.token();
 Name name = S.name();
 pos = S.pos();
 JCExpression type;
 boolean isVoid = S.token() == VOID;
 if (isVoid) {
 if (annosAfterParams.nonEmpty())
 illegal(annosAfterParams.head.pos);
 type = to(F.at(pos).TypeIdent(TypeTags.VOID));
 S.nextToken();
 } else {
-mods.annotations = mods.annotations.appendList(annosAfterParams);
+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 (S.token() == LPAREN && !isInterface && type.getTag() == JCTree.IDENT) {
 if (isInterface || name != className)
 if (S.token() == LBRACE) {
 body = block();
 }
 }
 }
 JCMethodDecl result =
 toP(F.at(pos).MethodDef(mods, name, type, typarams,
 params, receiverAnnotations, thrown,
 body, defaultValue));
 attach(result, dc);

changeset 4870	a132763160d7
parent 4704	5206047418c2
child 5013	e942b2e52479