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

-:825f23a4f262
+:e2722bd43f3a
 allowCovariantReturns = source.allowCovariantReturns();
 allowAnonOuterThis = source.allowAnonOuterThis();
 relax = (options.get("-retrofit") != null ||
 options.get("-relax") != null);
 useBeforeDeclarationWarning = options.get("useBeforeDeclarationWarning") != null;
+allowInvokedynamic = options.get("invokedynamic") != null;
 }
 /** Switch: relax some constraints for retrofit mode.
 */
 boolean relax;
 /** Switch: allow references to surrounding object from anonymous
 * objects during constructor call?
 */
 boolean allowAnonOuterThis;
+/** Switch: allow invokedynamic syntax
+*/
+boolean allowInvokedynamic;
 /**
 * Switch: warn about use of variable before declaration?
 * RFE: 6425594
 */
 l.head.pos(), types.upperBound(attribTree(l.head, env, VAL, Infer.anyPoly))));
 return argtypes.toList();
 }
 /** Attribute a type argument list, returning a list of types.
-*/
+*  Caller is responsible for calling checkRefTypes.
-List<Type> attribTypes(List<JCExpression> trees, Env<AttrContext> env) {
+*/
+List<Type> attribAnyTypes(List<JCExpression> trees, Env<AttrContext> env) {
 ListBuffer<Type> argtypes = new ListBuffer<Type>();
 for (List<JCExpression> l = trees; l.nonEmpty(); l = l.tail)
-argtypes.append(chk.checkRefType(l.head.pos(), attribType(l.head, env)));
+argtypes.append(attribType(l.head, env));
 return argtypes.toList();
 }
+/** Attribute a type argument list, returning a list of types.
+*  Check that all the types are references.
+*/
+List<Type> attribTypes(List<JCExpression> trees, Env<AttrContext> env) {
+List<Type> types = attribAnyTypes(trees, env);
+return chk.checkRefTypes(trees, types);
+}
 /**
 * Attribute type variables (of generic classes or methods).
 * Compound types are attributed later in attribBounds.
 * @param typarams the type variables to enter
 // The types of the actual method arguments.
 List<Type> argtypes;
 // The types of the actual method type arguments.
 List<Type> typeargtypes = null;
+boolean typeargtypesNonRefOK = false;
 Name methName = TreeInfo.name(tree.meth);
 boolean isConstructorCall =
 methName == names._this || methName == names._super;
 result = tree.type = syms.voidType;
 } else {
 // Otherwise, we are seeing a regular method call.
 // Attribute the arguments, yielding list of argument types, ...
 argtypes = attribArgs(tree.args, localEnv);
-typeargtypes = attribTypes(tree.typeargs, localEnv);
+typeargtypes = attribAnyTypes(tree.typeargs, localEnv);
 // ... and attribute the method using as a prototype a methodtype
 // whose formal argument types is exactly the list of actual
 // arguments (this will also set the method symbol).
 Type mpt = newMethTemplate(argtypes, typeargtypes);
 ClassType(restype.getEnclosingType(),
 List.<Type>of(new WildcardType(types.erasure(qualifier),
 BoundKind.EXTENDS,
 syms.boundClass)),
 restype.tsym);
+}
+// as a special case, MethodHandle.<T>invoke(abc) and InvokeDynamic.<T>foo(abc)
+// has type <T>, and T can be a primitive type.
+if (tree.meth.getTag() == JCTree.SELECT && !typeargtypes.isEmpty()) {
+Type selt = ((JCFieldAccess) tree.meth).selected.type;
+if ((selt == syms.methodHandleType && methName == names.invoke) || selt == syms.invokeDynamicType) {
+assert types.isSameType(restype, typeargtypes.head) : mtype;
+typeargtypesNonRefOK = true;
+}
+}
+if (!typeargtypesNonRefOK) {
+chk.checkRefTypes(tree.typeargs, typeargtypes);
 }
 // Check that value of resulting type is admissible in the
 // current context.  Also, capture the return type
 result = check(tree, capture(restype), VAL, pkind, pt);

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

comparison: src/share/classes/com/sun/tools/javac/comp/Attr.java

src/share/classes/com/sun/tools/javac/comp/Attr.java