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

-:9448fe783fd2
+:3343b22e2761
 package com.sun.tools.javac.parser;
 import java.util.*;
+import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.parser.Tokens.*;
 import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 this.allowDiamond = source.allowDiamond();
 this.allowMulticatch = source.allowMulticatch();
 this.allowStringFolding = fac.options.getBoolean("allowStringFolding", true);
 this.allowLambda = source.allowLambda() &&
 fac.options.isSet("allowLambda");
+this.allowMethodReferences = source.allowMethodReferences() &&
+fac.options.isSet("allowMethodReferences");
 this.keepDocComments = keepDocComments;
 docComments = keepDocComments ? new HashMap<JCTree,String>() : null;
 this.keepLineMap = keepLineMap;
 this.errorTree = F.Erroneous();
 endPosTable = newEndPosTable(keepEndPositions);
 boolean allowStringFolding;
 /** Switch: should we recognize lambda expressions?
 */
 boolean allowLambda;
+/** Switch: should we allow method/constructor references?
+*/
+boolean allowMethodReferences;
 /** Switch: should we keep docComments?
 */
 boolean keepDocComments;
 while (prec(token.kind) >= minprec) {
 opStack[top] = topOp;
 top++;
 topOp = token;
 nextToken();
-odStack[top] = (topOp.kind == INSTANCEOF) ? parseType() : term3();
+odStack[top] = (topOp.kind == INSTANCEOF) ? parseType() : term3NoParams();
 while (top > 0 && prec(topOp.kind) >= prec(token.kind)) {
 odStack[top-1] = makeOp(topOp.pos, topOp.kind, odStack[top-1],
 odStack[top]);
 top--;
 topOp = opStack[top];
 *                 | [TypeArguments] SUPER SuperSuffix
 *                 | NEW [TypeArguments] Creator
 *                 | "(" Arguments ")" "->" ( Expression | Block )
 *                 | Ident "->" ( Expression | Block )
 *                 | Ident { "." Ident }
+*                 | Expression3 MemberReferenceSuffix
 *                   [ "[" ( "]" BracketsOpt "." CLASS | Expression "]" )
 *                   | Arguments
 *                   | "." ( CLASS | THIS | [TypeArguments] SUPER Arguments | NEW [TypeArguments] InnerCreator )
 *                   ]
 *                 | BasicType BracketsOpt "." CLASS
 (token.kind == INTLITERAL || token.kind == LONGLITERAL) &&
 token.radix() == 10) {
 mode = EXPR;
 t = literal(names.hyphen, pos);
 } else {
-t = term3();
+t = term3NoParams();
 return F.at(pos).Unary(unoptag(tk), t);
 }
 } else return illegal();
 break;
 case LPAREN:
 //implicit n-ary lambda
 t = lambdaExpressionOrStatement(true, peekToken(FINAL), pos);
 break;
 } else {
 nextToken();
-mode = EXPR | TYPE | NOPARAMS;
+mode = EXPR | TYPE;
-t = term3();
+t = term3NoParams();
 if ((mode & TYPE) != 0 && token.kind == LT) {
 // Could be a cast to a parameterized type
 JCTree.Tag op = JCTree.Tag.LT;
 int pos1 = token.pos;
 nextToken();
 accept(RPAREN);
 lastmode = mode;
 mode = EXPR;
 if ((lastmode & EXPR) == 0) {
-JCExpression t1 = term3();
+JCExpression t1 = term3NoParams();
 return F.at(pos).TypeCast(t, t1);
 } else if ((lastmode & TYPE) != 0) {
 switch (token.kind) {
 /*case PLUSPLUS: case SUBSUB: */
 case BANG: case TILDE:
 case DOUBLELITERAL: case CHARLITERAL: case STRINGLITERAL:
 case TRUE: case FALSE: case NULL:
 case NEW: case IDENTIFIER: case ASSERT: case ENUM:
 case BYTE: case SHORT: case CHAR: case INT:
 case LONG: case FLOAT: case DOUBLE: case BOOLEAN: case VOID:
-JCExpression t1 = term3();
+JCExpression t1 = term3NoParams();
 return F.at(pos).TypeCast(t, t1);
 }
 }
 } else {
 return illegal();
 }
 }
 // typeArgs saved for next loop iteration.
 t = toP(F.at(pos).Select(t, ident()));
 break;
+case LT:
+if ((mode & (TYPE | NOPARAMS)) == 0) {
+//could be an unbound method reference whose qualifier
+//is a generic type i.e. A<S>#m
+mode = EXPR | TYPE;
+JCTree.Tag op = JCTree.Tag.LT;
+int pos1 = token.pos;
+nextToken();
+mode |= EXPR | TYPE | TYPEARG;
+JCExpression t1 = term3();
+if ((mode & TYPE) != 0 &&
+(token.kind == COMMA || token.kind == GT)) {
+mode = TYPE;
+ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
+args.append(t1);
+while (token.kind == COMMA) {
+nextToken();
+args.append(typeArgument());
+}
+accept(GT);
+t = toP(F.at(pos1).TypeApply(t, args.toList()));
+checkGenerics();
+while (token.kind == DOT) {
+nextToken();
+mode = TYPE;
+t = toP(F.at(token.pos).Select(t, ident()));
+t = typeArgumentsOpt(t);
+}
+if (token.kind != HASH) {
+//method reference expected here
+t = illegal();
+}
+mode = EXPR;
+break;
+} else if ((mode & EXPR) != 0) {
+//rollback - it was a binary expression
+mode = EXPR;
+JCExpression e = term2Rest(t1, TreeInfo.shiftPrec);
+t = F.at(pos1).Binary(op, t, e);
+t = termRest(term1Rest(term2Rest(t, TreeInfo.orPrec)));
+}
+}
+break loop;
 default:
 break loop;
 }
 }
 }
 break;
 default:
 return illegal();
 }
 return term3Rest(t, typeArgs);
+}
+JCExpression term3NoParams() {
+try {
+mode |= NOPARAMS;
+return term3();
+} finally {
+mode &= ~NOPARAMS;
+}
 }
 JCExpression term3Rest(JCExpression t, List<JCExpression> typeArgs) {
 if (typeArgs != null) illegal();
 while (true) {
 } else {
 t = toP(F.at(pos1).Select(t, ident()));
 t = argumentsOpt(typeArgs, typeArgumentsOpt(t));
 typeArgs = null;
 }
+} else if ((mode & EXPR) != 0 && token.kind == HASH) {
+mode = EXPR;
+if (typeArgs != null) return illegal();
+accept(HASH);
+t = memberReferenceSuffix(pos1, t);
 } else {
 break;
 }
 }
 while ((token.kind == PLUSPLUS || token.kind == SUBSUB) && (mode & EXPR) != 0) {
 */
 JCExpression superSuffix(List<JCExpression> typeArgs, JCExpression t) {
 nextToken();
 if (token.kind == LPAREN || typeArgs != null) {
 t = arguments(typeArgs, t);
+} else if (token.kind == HASH) {
+if (typeArgs != null) return illegal();
+t = memberReferenceSuffix(t);
 } else {
 int pos = token.pos;
 accept(DOT);
 typeArgs = (token.kind == LT) ? typeArguments(false) : null;
 t = toP(F.at(pos).Select(t, ident()));
 mode = TYPE;
 } else {
 syntaxError(token.pos, "dot.class.expected");
 }
 return t;
+}
+/**
+* MemberReferenceSuffix = "#" [TypeArguments] Ident
+*                       | "#" [TypeArguments] "new"
+*/
+JCExpression memberReferenceSuffix(JCExpression t) {
+int pos1 = token.pos;
+accept(HASH);
+return memberReferenceSuffix(pos1, t);
+}
+JCExpression memberReferenceSuffix(int pos1, JCExpression t) {
+checkMethodReferences();
+mode = EXPR;
+List<JCExpression> typeArgs = null;
+if (token.kind == LT) {
+typeArgs = typeArguments(false);
+}
+Name refName = null;
+ReferenceMode refMode = null;
+if (token.kind == NEW) {
+refMode = ReferenceMode.NEW;
+refName = names.init;
+nextToken();
+} else {
+refMode = ReferenceMode.INVOKE;
+refName = ident();
+}
+return toP(F.at(t.getStartPosition()).Reference(refMode, refName, t, typeArgs));
 }
 /** Creator = Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
 */
 JCExpression creator(int newpos, List<JCExpression> typeArgs) {
 if (!allowLambda) {
 log.error(token.pos, "lambda.not.supported.in.source", source.name);
 allowLambda = true;
 }
 }
+void checkMethodReferences() {
+if (!allowMethodReferences) {
+log.error(token.pos, "method.references.not.supported.in.source", source.name);
+allowMethodReferences = 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