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

-:ab1356297c67
+:005bec70ca27
 TreeInfo treeinfo;
 Types types;
 JCDiagnostic.Factory diags;
 public final boolean boxingEnabled; // = source.allowBoxing();
 public final boolean varargsEnabled; // = source.allowVarargs();
-public final boolean allowInvokedynamic; // = options.get("invokedynamic");
+public final boolean allowPolymorphicSignature;
 private final boolean debugResolve;
 public static Resolve instance(Context context) {
 Resolve instance = context.get(resolveKey);
 if (instance == null)
 Source source = Source.instance(context);
 boxingEnabled = source.allowBoxing();
 varargsEnabled = source.allowVarargs();
 Options options = Options.instance(context);
 debugResolve = options.get("debugresolve") != null;
-allowInvokedynamic = options.get("invokedynamic") != null;
+allowPolymorphicSignature = source.allowPolymorphicSignature() || options.get("invokedynamic") != null;
 }
 /** error symbols, which are returned when resolution fails
 */
 final SymbolNotFoundError varNotFound;
 List<Type> typeargtypes,
 boolean allowBoxing,
 boolean useVarargs,
 Warner warn)
 throws Infer.InferenceException {
+assert ((m.flags() & (POLYMORPHIC_SIGNATURE|HYPOTHETICAL)) != POLYMORPHIC_SIGNATURE);
 if (useVarargs && (m.flags() & VARARGS) == 0) return null;
 Type mt = types.memberType(site, m);
 // tvars is the list of formal type variables for which type arguments
 // need to inferred.
 boolean useVarargs,
 boolean operator) {
 if (sym.kind == ERR) return bestSoFar;
 if (!sym.isInheritedIn(site.tsym, types)) return bestSoFar;
 assert sym.kind < AMBIGUOUS;
+if ((sym.flags() & POLYMORPHIC_SIGNATURE) != 0 && allowPolymorphicSignature) {
+assert(site.tag == CLASS);
+// Never match a MethodHandle.invoke directly.
+if (useVarargs | allowBoxing | operator)
+return bestSoFar;
+// Supply an exactly-typed implicit method instead.
+sym = findPolymorphicSignatureInstance(env, sym.owner.type, sym.name, (MethodSymbol) sym, argtypes, typeargtypes);
+}
 try {
 if (rawInstantiate(env, site, sym, argtypes, typeargtypes,
 allowBoxing, useVarargs, Warner.noWarnings) == null) {
 // inapplicable
 switch (bestSoFar.kind) {
 List<Type> argtypes,
 List<Type> typeargtypes,
 boolean allowBoxing,
 boolean useVarargs,
 boolean operator) {
+Symbol bestSoFar = methodNotFound;
+if ((site.tsym.flags() & POLYMORPHIC_SIGNATURE) != 0 &&
+allowPolymorphicSignature &&
+site.tag == CLASS &&
+!(useVarargs | allowBoxing | operator)) {
+// supply an exactly-typed implicit method in java.dyn.InvokeDynamic
+bestSoFar = findPolymorphicSignatureInstance(env, site, name, null, argtypes, typeargtypes);
+}
 return findMethod(env,
 site,
 name,
 argtypes,
 typeargtypes,
 site.tsym.type,
 true,
-methodNotFound,
+bestSoFar,
 allowBoxing,
 useVarargs,
 operator);
 }
 // where
 *                   takes place.
 *  @param name      The method's name.
 *  @param argtypes  The method's value arguments.
 *  @param typeargtypes The method's type arguments
 */
-Symbol findImplicitMethod(Env<AttrContext> env,
+Symbol findPolymorphicSignatureInstance(Env<AttrContext> env,
 Type site,
 Name name,
-List<Type> argtypes,
+MethodSymbol spMethod,  // sig. poly. method or null if none
-List<Type> typeargtypes) {
+List<Type> argtypes,
-assert allowInvokedynamic;
+List<Type> typeargtypes) {
-assert site == syms.invokeDynamicType || (site == syms.methodHandleType && name == names.invoke);
+assert allowPolymorphicSignature;
+//assert site == syms.invokeDynamicType || site == syms.methodHandleType : site;
 ClassSymbol c = (ClassSymbol) site.tsym;
 Scope implicit = c.members().next;
 if (implicit == null) {
 c.members().next = implicit = new Scope(c);
 }
 restype = typeargtypes.head;
 if (!typeargtypes.tail.isEmpty())
 return methodNotFound;
 }
 List<Type> paramtypes = Type.map(argtypes, implicitArgType);
+long flags;
+List<Type> exType;
+if (spMethod != null) {
+exType = spMethod.getThrownTypes();
+flags = spMethod.flags() & AccessFlags;
+} else {
+// make it throw all exceptions
+//assert(site == syms.invokeDynamicType);
+exType = List.of(syms.throwableType);
+flags = PUBLIC | STATIC;
+}
 MethodType mtype = new MethodType(paramtypes,
 restype,
-List.<Type>nil(),
+exType,
 syms.methodClass);
-int flags = PUBLIC | ABSTRACT;
+flags |= ABSTRACT | HYPOTHETICAL | POLYMORPHIC_SIGNATURE;
-if (site == syms.invokeDynamicType)  flags |= STATIC;
 Symbol m = null;
 for (Scope.Entry e = implicit.lookup(name);
 e.scope != null;
 e = e.next()) {
 Symbol sym = e.sym;
 sym = findMethod(env, site, name, argtypes, typeargtypes,
 steps.head.isBoxingRequired(),
 env.info.varArgs = steps.head.isVarargsRequired(), false);
 methodResolutionCache.put(steps.head, sym);
 steps = steps.tail;
-}
-if (sym.kind >= AMBIGUOUS &&
-allowInvokedynamic &&
-(site == syms.invokeDynamicType ||
-site == syms.methodHandleType && name == names.invoke)) {
-// lookup failed; supply an exactly-typed implicit method
-sym = findImplicitMethod(env, site, name, argtypes, typeargtypes);
-env.info.varArgs = false;
 }
 if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
 MethodResolutionPhase errPhase =
 firstErroneousResolutionPhase();
 sym = access(methodResolutionCache.get(errPhase),

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

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

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