Mercurial > hg > openjdk > jigsaw > langtools
changeset 1529:dbc94b8363dd
8000931: Cleanup Resolve.java
Summary: Unify all method resolution routines
Reviewed-by: jjg
| author | mcimadamore |
|---|---|
| date | Sun, 04 Nov 2012 11:01:49 +0000 |
| parents | d7d932236fee |
| children | 9bce0c73583d |
| files | src/share/classes/com/sun/tools/javac/comp/Lower.java src/share/classes/com/sun/tools/javac/comp/Resolve.java test/tools/javac/7132880/T7132880.out test/tools/javac/Diagnostics/6799605/T6799605.out test/tools/javac/defaultMethods/Neg12.out test/tools/javac/generics/inference/6611449/T6611449.out test/tools/javac/generics/inference/7086601/T7086601a.out test/tools/javac/resolve/tests/AmbiguityPrecedence.java |
| diffstat | 8 files changed, 545 insertions(+), 600 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/comp/Lower.java Sun Nov 04 10:59:42 2012 +0000 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java Sun Nov 04 11:01:49 2012 +0000 @@ -502,7 +502,7 @@ JCNewClass tree = make.NewClass(null, null, make.QualIdent(ctype.tsym), args, null); tree.constructor = rs.resolveConstructor( - make_pos, attrEnv, ctype, TreeInfo.types(args), null, false, false); + make_pos, attrEnv, ctype, TreeInfo.types(args), List.<Type>nil()); tree.type = ctype; return tree; }
--- a/src/share/classes/com/sun/tools/javac/comp/Resolve.java Sun Nov 04 10:59:42 2012 +0000 +++ b/src/share/classes/com/sun/tools/javac/comp/Resolve.java Sun Nov 04 11:01:49 2012 +0000 @@ -51,6 +51,8 @@ import java.util.EnumMap; import java.util.EnumSet; import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; @@ -450,22 +452,9 @@ List<Type> typeargtypes, boolean allowBoxing, boolean useVarargs, - Warner warn) - throws Infer.InferenceException { - if (useVarargs && (m.flags() & VARARGS) == 0) { - //better error recovery - if we stumbled upon a non-varargs method - //during varargs applicability phase, the method should be treated as - //not applicable; the reason for inapplicability can be found in the - //candidate for 'm' that was created during the BOX phase. - Candidate prevCandidate = currentResolutionContext.getCandidate(m, BOX); - JCDiagnostic details = null; - if (prevCandidate != null && !prevCandidate.isApplicable()) { - details = prevCandidate.details; - } - throw inapplicableMethodException.setMessage(details); - } + Warner warn) throws Infer.InferenceException { + Type mt = types.memberType(site, m); - // tvars is the list of formal type variables for which type arguments // need to inferred. List<Type> tvars = List.nil(); @@ -1023,8 +1012,11 @@ boolean allowBoxing, boolean useVarargs, boolean operator) { - if (sym.kind == ERR) return bestSoFar; - if (!sym.isInheritedIn(site.tsym, types)) return bestSoFar; + if (sym.kind == ERR || + !sym.isInheritedIn(site.tsym, types) || + (useVarargs && (sym.flags() & VARARGS) == 0)) { + return bestSoFar; + } Assert.check(sym.kind < AMBIGUOUS); try { Type mt = rawInstantiate(env, site, sym, null, argtypes, typeargtypes, @@ -1035,13 +1027,13 @@ if (!operator) currentResolutionContext.addInapplicableCandidate(sym, ex.getDiagnostic()); switch (bestSoFar.kind) { - case ABSENT_MTH: - return new InapplicableSymbolError(currentResolutionContext); - case WRONG_MTH: - if (operator) return bestSoFar; - bestSoFar = new InapplicableSymbolsError(currentResolutionContext); - default: - return bestSoFar; + case ABSENT_MTH: + return new InapplicableSymbolError(currentResolutionContext); + case WRONG_MTH: + if (operator) return bestSoFar; + bestSoFar = new InapplicableSymbolsError(currentResolutionContext); + default: + return bestSoFar; } } if (!isAccessible(env, site, sym)) { @@ -1330,7 +1322,7 @@ } } - Symbol lookupMethod(Env<AttrContext> env, + Symbol findMethodInScope(Env<AttrContext> env, Type site, Name name, List<Type> argtypes, @@ -1414,7 +1406,7 @@ List<Type>[] itypes = (List<Type>[])new List[] { List.<Type>nil(), List.<Type>nil() }; InterfaceLookupPhase iphase = InterfaceLookupPhase.ABSTRACT_OK; for (TypeSymbol s : superclasses(intype)) { - bestSoFar = lookupMethod(env, site, name, argtypes, typeargtypes, + bestSoFar = findMethodInScope(env, site, name, argtypes, typeargtypes, s.members(), bestSoFar, allowBoxing, useVarargs, operator, true); if (name == names.init) return bestSoFar; iphase = (iphase == null) ? null : iphase.update(s, this); @@ -1436,7 +1428,7 @@ if (!itype.isInterface()) continue; //skip j.l.Object (included by Types.closure()) if (iphase2 == InterfaceLookupPhase.DEFAULT_OK && (itype.tsym.flags() & DEFAULT) == 0) continue; - bestSoFar = lookupMethod(env, site, name, argtypes, typeargtypes, + bestSoFar = findMethodInScope(env, site, name, argtypes, typeargtypes, itype.tsym.members(), bestSoFar, allowBoxing, useVarargs, operator, true); if (concrete != bestSoFar && concrete.kind < ERR && bestSoFar.kind < ERR && @@ -1936,7 +1928,7 @@ ((InapplicableSymbolError)errSym).errCandidate().sym : accessedSym; List<Type> argtypes2 = Type.map(argtypes, - deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, msym, currentResolutionContext.firstErroneousResolutionPhase())); + deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, msym, currentResolutionContext.step)); if (msym != accessedSym) { //fixup deferred type caches - this 'hack' is required because the symbol @@ -2030,33 +2022,14 @@ Name name, List<Type> argtypes, List<Type> typeargtypes) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = new MethodResolutionContext(); - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= ERRONEOUS) { - currentResolutionContext.step = env.info.pendingResolutionPhase = steps.head; - sym = findFun(env, name, argtypes, typeargtypes, - steps.head.isBoxingRequired, - steps.head.isVarargsRequired); - currentResolutionContext.resolutionCache.put(steps.head, sym); - steps = steps.tail; + return lookupMethod(env, pos, env.enclClass.sym, new BasicLookupHelper(name, env.enclClass.type, argtypes, typeargtypes) { + @Override + Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return findFun(env, name, argtypes, typeargtypes, + phase.isBoxingRequired(), + phase.isVarargsRequired()); } - if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error - MethodResolutionPhase errPhase = - currentResolutionContext.firstErroneousResolutionPhase(); - sym = accessMethod(currentResolutionContext.resolutionCache.get(errPhase), - pos, env.enclClass.sym.type, name, false, argtypes, typeargtypes); - env.info.pendingResolutionPhase = errPhase; - } - return sym; - } - finally { - currentResolutionContext = prevResolutionContext; - } + }); } /** Resolve a qualified method identifier @@ -2082,40 +2055,27 @@ DiagnosticPosition pos, Env<AttrContext> env, Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = resolveContext; - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= ERRONEOUS) { - currentResolutionContext.step = env.info.pendingResolutionPhase = steps.head; - sym = findMethod(env, site, name, argtypes, typeargtypes, - steps.head.isBoxingRequired(), - steps.head.isVarargsRequired(), false); - currentResolutionContext.resolutionCache.put(steps.head, sym); - steps = steps.tail; + return lookupMethod(env, pos, location, resolveContext, new BasicLookupHelper(name, site, argtypes, typeargtypes) { + @Override + Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return findMethod(env, site, name, argtypes, typeargtypes, + phase.isBoxingRequired(), + phase.isVarargsRequired(), false); } - if (sym.kind >= AMBIGUOUS) { - //if nothing is found return the 'first' error - MethodResolutionPhase errPhase = - currentResolutionContext.firstErroneousResolutionPhase(); - sym = accessMethod(currentResolutionContext.resolutionCache.get(errPhase), - pos, location, site, name, true, argtypes, typeargtypes); - env.info.pendingResolutionPhase = errPhase; - } else if (allowMethodHandles) { - MethodSymbol msym = (MethodSymbol)sym; - if (msym.isSignaturePolymorphic(types)) { - env.info.pendingResolutionPhase = BASIC; - return findPolymorphicSignatureInstance(env, sym, argtypes); + @Override + Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) { + if (sym.kind >= AMBIGUOUS) { + sym = super.access(env, pos, location, sym); + } else if (allowMethodHandles) { + MethodSymbol msym = (MethodSymbol)sym; + if (msym.isSignaturePolymorphic(types)) { + env.info.pendingResolutionPhase = BASIC; + return findPolymorphicSignatureInstance(env, sym, argtypes); + } } + return sym; } - return sym; - } - finally { - currentResolutionContext = prevResolutionContext; - } + }); } /** Find or create an implicit method of exactly the given type (after erasure). @@ -2183,38 +2143,53 @@ List<Type> typeargtypes) { return resolveConstructor(new MethodResolutionContext(), pos, env, site, argtypes, typeargtypes); } + private Symbol resolveConstructor(MethodResolutionContext resolveContext, - DiagnosticPosition pos, + final DiagnosticPosition pos, Env<AttrContext> env, Type site, List<Type> argtypes, List<Type> typeargtypes) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = resolveContext; - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= ERRONEOUS) { - currentResolutionContext.step = env.info.pendingResolutionPhase = steps.head; - sym = findConstructor(pos, env, site, argtypes, typeargtypes, - steps.head.isBoxingRequired(), - steps.head.isVarargsRequired()); - currentResolutionContext.resolutionCache.put(steps.head, sym); - steps = steps.tail; + return lookupMethod(env, pos, site.tsym, resolveContext, new BasicLookupHelper(names.init, site, argtypes, typeargtypes) { + @Override + Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return findConstructor(pos, env, site, argtypes, typeargtypes, + phase.isBoxingRequired(), + phase.isVarargsRequired()); } - if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error - MethodResolutionPhase errPhase = currentResolutionContext.firstErroneousResolutionPhase(); - sym = accessMethod(currentResolutionContext.resolutionCache.get(errPhase), - pos, site, names.init, true, argtypes, typeargtypes); - env.info.pendingResolutionPhase = errPhase; - } - return sym; - } - finally { - currentResolutionContext = prevResolutionContext; - } + }); + } + + /** Resolve a constructor, throw a fatal error if not found. + * @param pos The position to use for error reporting. + * @param env The environment current at the method invocation. + * @param site The type to be constructed. + * @param argtypes The types of the invocation's value arguments. + * @param typeargtypes The types of the invocation's type arguments. + */ + public MethodSymbol resolveInternalConstructor(DiagnosticPosition pos, Env<AttrContext> env, + Type site, + List<Type> argtypes, + List<Type> typeargtypes) { + MethodResolutionContext resolveContext = new MethodResolutionContext(); + resolveContext.internalResolution = true; + Symbol sym = resolveConstructor(resolveContext, pos, env, site, argtypes, typeargtypes); + if (sym.kind == MTH) return (MethodSymbol)sym; + else throw new FatalError( + diags.fragment("fatal.err.cant.locate.ctor", site)); + } + + Symbol findConstructor(DiagnosticPosition pos, Env<AttrContext> env, + Type site, List<Type> argtypes, + List<Type> typeargtypes, + boolean allowBoxing, + boolean useVarargs) { + Symbol sym = findMethod(env, site, + names.init, argtypes, + typeargtypes, allowBoxing, + useVarargs, false); + chk.checkDeprecated(pos, env.info.scope.owner, sym); + return sym; } /** Resolve constructor using diamond inference. @@ -2232,47 +2207,36 @@ Type site, List<Type> argtypes, List<Type> typeargtypes) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = new MethodResolutionContext(); - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= ERRONEOUS) { - currentResolutionContext.step = env.info.pendingResolutionPhase = steps.head; - sym = findDiamond(env, site, argtypes, typeargtypes, - steps.head.isBoxingRequired(), - steps.head.isVarargsRequired()); - currentResolutionContext.resolutionCache.put(steps.head, sym); - steps = steps.tail; + return lookupMethod(env, pos, site.tsym, new BasicLookupHelper(names.init, site, argtypes, typeargtypes) { + @Override + Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return findDiamond(env, site, argtypes, typeargtypes, + phase.isBoxingRequired(), + phase.isVarargsRequired()); } - if (sym.kind >= AMBIGUOUS) { - Symbol errSym = - currentResolutionContext.resolutionCache.get(currentResolutionContext.firstErroneousResolutionPhase()); - final JCDiagnostic details = errSym.kind == WRONG_MTH ? - ((InapplicableSymbolError)errSym).errCandidate().details : - null; - errSym = new InapplicableSymbolError(errSym.kind, "diamondError", currentResolutionContext) { - @Override - JCDiagnostic getDiagnostic(DiagnosticType dkind, DiagnosticPosition pos, - Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) { - String key = details == null ? - "cant.apply.diamond" : - "cant.apply.diamond.1"; - return diags.create(dkind, log.currentSource(), pos, key, - diags.fragment("diamond", site.tsym), details); - } - }; - MethodResolutionPhase errPhase = currentResolutionContext.firstErroneousResolutionPhase(); - sym = accessMethod(errSym, pos, site, names.init, true, argtypes, typeargtypes); - env.info.pendingResolutionPhase = errPhase; + @Override + Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) { + if (sym.kind >= AMBIGUOUS) { + final JCDiagnostic details = sym.kind == WRONG_MTH ? + ((InapplicableSymbolError)sym).errCandidate().details : + null; + sym = new InapplicableSymbolError(sym.kind, "diamondError", currentResolutionContext) { + @Override + JCDiagnostic getDiagnostic(DiagnosticType dkind, DiagnosticPosition pos, + Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) { + String key = details == null ? + "cant.apply.diamond" : + "cant.apply.diamond.1"; + return diags.create(dkind, log.currentSource(), pos, key, + diags.fragment("diamond", site.tsym), details); + } + }; + sym = accessMethod(sym, pos, site, names.init, true, argtypes, typeargtypes); + env.info.pendingResolutionPhase = currentResolutionContext.step; + } + return sym; } - return sym; - } - finally { - currentResolutionContext = prevResolutionContext; - } + }); } /** This method scans all the constructor symbol in a given class scope - @@ -2319,392 +2283,7 @@ return bestSoFar; } - /** - * Resolution of member references is typically done as a single - * overload resolution step, where the argument types A are inferred from - * the target functional descriptor. - * - * If the member reference is a method reference with a type qualifier, - * a two-step lookup process is performed. The first step uses the - * expected argument list A, while the second step discards the first - * type from A (which is treated as a receiver type). - * - * There are two cases in which inference is performed: (i) if the member - * reference is a constructor reference and the qualifier type is raw - in - * which case diamond inference is used to infer a parameterization for the - * type qualifier; (ii) if the member reference is an unbound reference - * where the type qualifier is raw - in that case, during the unbound lookup - * the receiver argument type is used to infer an instantiation for the raw - * qualifier type. - * - * When a multi-step resolution process is exploited, it is an error - * if two candidates are found (ambiguity). - * - * This routine returns a pair (T,S), where S is the member reference symbol, - * and T is the type of the class in which S is defined. This is necessary as - * the type T might be dynamically inferred (i.e. if constructor reference - * has a raw qualifier). - */ - Pair<Symbol, ReferenceLookupHelper> resolveMemberReference(DiagnosticPosition pos, - Env<AttrContext> env, - JCMemberReference referenceTree, - Type site, - Name name, List<Type> argtypes, - List<Type> typeargtypes, - boolean boxingAllowed) { - //step 1 - bound lookup - ReferenceLookupHelper boundLookupHelper = name.equals(names.init) ? - new ConstructorReferenceLookupHelper(referenceTree, site, argtypes, typeargtypes, boxingAllowed) : - new MethodReferenceLookupHelper(referenceTree, name, site, argtypes, typeargtypes, boxingAllowed); - Env<AttrContext> boundEnv = env.dup(env.tree, env.info.dup()); - Symbol boundSym = findMemberReference(boundEnv, boundLookupHelper); - - //step 2 - unbound lookup - ReferenceLookupHelper unboundLookupHelper = boundLookupHelper.unboundLookup(); - Env<AttrContext> unboundEnv = env.dup(env.tree, env.info.dup()); - Symbol unboundSym = findMemberReference(unboundEnv, unboundLookupHelper); - - //merge results - Pair<Symbol, ReferenceLookupHelper> res; - if (unboundSym.kind != MTH) { - res = new Pair<Symbol, ReferenceLookupHelper>(boundSym, boundLookupHelper); - env.info.pendingResolutionPhase = boundEnv.info.pendingResolutionPhase; - } else if (boundSym.kind == MTH) { - res = new Pair<Symbol, ReferenceLookupHelper>(ambiguityError(boundSym, unboundSym), boundLookupHelper); - env.info.pendingResolutionPhase = boundEnv.info.pendingResolutionPhase; - } else { - res = new Pair<Symbol, ReferenceLookupHelper>(unboundSym, unboundLookupHelper); - env.info.pendingResolutionPhase = unboundEnv.info.pendingResolutionPhase; - } - - return res; - } - - /** - * Helper for defining custom method-like lookup logic; a lookup helper - * provides hooks for (i) the actual lookup logic and (ii) accessing the - * lookup result (this step might result in compiler diagnostics to be generated) - */ - abstract class LookupHelper { - - /** name of the symbol to lookup */ - Name name; - - /** location in which the lookup takes place */ - Type site; - - /** actual types used during the lookup */ - List<Type> argtypes; - - /** type arguments used during the lookup */ - List<Type> typeargtypes; - - LookupHelper(Name name, Type site, List<Type> argtypes, List<Type> typeargtypes) { - this.name = name; - this.site = site; - this.argtypes = argtypes; - this.typeargtypes = typeargtypes; - } - - /** - * Search for a symbol under a given overload resolution phase - this method - * is usually called several times, once per each overload resolution phase - */ - abstract Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase); - - /** - * Validate the result of the lookup - */ - abstract Symbol access(Env<AttrContext> env, Symbol symbol); - } - - /** - * Helper class for member reference lookup. A reference lookup helper - * defines the basic logic for member reference lookup; a method gives - * access to an 'unbound' helper used to perform an unbound member - * reference lookup. - */ - abstract class ReferenceLookupHelper extends LookupHelper { - - /** The member reference tree */ - JCMemberReference referenceTree; - - /** Max overload resolution phase handled by this helper */ - MethodResolutionPhase maxPhase; - - ReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, - List<Type> argtypes, List<Type> typeargtypes, boolean boxingAllowed) { - super(name, site, argtypes, typeargtypes); - this.referenceTree = referenceTree; - this.maxPhase = boxingAllowed ? VARARITY : BASIC; - } - - /** - * Returns an unbound version of this lookup helper. By default, this - * method returns an dummy lookup helper. - */ - ReferenceLookupHelper unboundLookup() { - //dummy loopkup helper that always return 'methodNotFound' - return new ReferenceLookupHelper(referenceTree, name, site, argtypes, typeargtypes, maxPhase.isBoxingRequired()) { - @Override - ReferenceLookupHelper unboundLookup() { - return this; - } - @Override - Symbol lookupReference(Env<AttrContext> env, MethodResolutionPhase phase) { - return methodNotFound; - } - @Override - ReferenceKind referenceKind(Symbol sym) { - Assert.error(); - return null; - } - }; - } - - /** - * Get the kind of the member reference - */ - abstract JCMemberReference.ReferenceKind referenceKind(Symbol sym); - - @Override - Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { - return (env.info.pendingResolutionPhase.ordinal() > maxPhase.ordinal()) ? - methodNotFound : lookupReference(env, phase); - } - - abstract Symbol lookupReference(Env<AttrContext> env, MethodResolutionPhase phase); - - Symbol access(Env<AttrContext> env, Symbol sym) { - if (sym.kind >= AMBIGUOUS) { - MethodResolutionPhase errPhase = currentResolutionContext.firstErroneousResolutionPhase(); - if (errPhase.ordinal() > maxPhase.ordinal()) { - errPhase = maxPhase; - } - env.info.pendingResolutionPhase = errPhase; - sym = currentResolutionContext.resolutionCache.get(errPhase); - } - return sym; - } - } - - /** - * Helper class for method reference lookup. The lookup logic is based - * upon Resolve.findMethod; in certain cases, this helper class has a - * corresponding unbound helper class (see UnboundMethodReferenceLookupHelper). - * In such cases, non-static lookup results are thrown away. - */ - class MethodReferenceLookupHelper extends ReferenceLookupHelper { - - MethodReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, - List<Type> argtypes, List<Type> typeargtypes, boolean boxingAllowed) { - super(referenceTree, name, site, argtypes, typeargtypes, boxingAllowed); - } - - protected Symbol lookupReferenceInternal(Env<AttrContext> env, MethodResolutionPhase phase) { - return findMethod(env, site, name, argtypes, typeargtypes, - phase.isBoxingRequired(), phase.isVarargsRequired(), syms.operatorNames.contains(name)); - } - - protected Symbol adjustLookupResult(Env<AttrContext> env, Symbol sym) { - return !TreeInfo.isStaticSelector(referenceTree.expr, names) || - sym.kind != MTH || - sym.isStatic() ? sym : new StaticError(sym); - } - - @Override - final Symbol lookupReference(Env<AttrContext> env, MethodResolutionPhase phase) { - return adjustLookupResult(env, lookupReferenceInternal(env, phase)); - } - - @Override - ReferenceLookupHelper unboundLookup() { - if (TreeInfo.isStaticSelector(referenceTree.expr, names) && - argtypes.nonEmpty() && - types.isSubtypeUnchecked(argtypes.head, site)) { - return new UnboundMethodReferenceLookupHelper(referenceTree, name, - site, argtypes, typeargtypes, maxPhase.isBoxingRequired()); - } else { - return super.unboundLookup(); - } - } - - @Override - ReferenceKind referenceKind(Symbol sym) { - if (sym.isStatic()) { - return TreeInfo.isStaticSelector(referenceTree.expr, names) ? - ReferenceKind.STATIC : ReferenceKind.STATIC_EVAL; - } else { - Name selName = TreeInfo.name(referenceTree.getQualifierExpression()); - return selName != null && selName == names._super ? - ReferenceKind.SUPER : - ReferenceKind.BOUND; - } - } - } - - /** - * Helper class for unbound method reference lookup. Essentially the same - * as the basic method reference lookup helper; main difference is that static - * lookup results are thrown away. If qualifier type is raw, an attempt to - * infer a parameterized type is made using the first actual argument (that - * would otherwise be ignored during the lookup). - */ - class UnboundMethodReferenceLookupHelper extends MethodReferenceLookupHelper { - - UnboundMethodReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, - List<Type> argtypes, List<Type> typeargtypes, boolean boxingAllowed) { - super(referenceTree, name, - site.isRaw() ? types.asSuper(argtypes.head, site.tsym) : site, - argtypes.tail, typeargtypes, boxingAllowed); - } - - @Override - protected Symbol adjustLookupResult(Env<AttrContext> env, Symbol sym) { - return sym.kind != MTH || !sym.isStatic() ? sym : new StaticError(sym); - } - - @Override - ReferenceLookupHelper unboundLookup() { - return this; - } - - @Override - ReferenceKind referenceKind(Symbol sym) { - return ReferenceKind.UNBOUND; - } - } - - /** - * Helper class for constructor reference lookup. The lookup logic is based - * upon either Resolve.findMethod or Resolve.findDiamond - depending on - * whether the constructor reference needs diamond inference (this is the case - * if the qualifier type is raw). A special erroneous symbol is returned - * if the lookup returns the constructor of an inner class and there's no - * enclosing instance in scope. - */ - class ConstructorReferenceLookupHelper extends ReferenceLookupHelper { - - boolean needsInference; - - ConstructorReferenceLookupHelper(JCMemberReference referenceTree, Type site, List<Type> argtypes, - List<Type> typeargtypes, boolean boxingAllowed) { - super(referenceTree, names.init, site, argtypes, typeargtypes, boxingAllowed); - if (site.isRaw()) { - this.site = new ClassType(site.getEnclosingType(), site.tsym.type.getTypeArguments(), site.tsym); - needsInference = true; - } - } - - @Override - protected Symbol lookupReference(Env<AttrContext> env, MethodResolutionPhase phase) { - Symbol sym = needsInference ? - findDiamond(env, site, argtypes, typeargtypes, phase.isBoxingRequired(), phase.isVarargsRequired()) : - findMethod(env, site, name, argtypes, typeargtypes, - phase.isBoxingRequired(), phase.isVarargsRequired(), syms.operatorNames.contains(name)); - return sym.kind != MTH || - site.getEnclosingType().hasTag(NONE) || - hasEnclosingInstance(env, site) ? - sym : new InvalidSymbolError(Kinds.MISSING_ENCL, sym, null) { - @Override - JCDiagnostic getDiagnostic(DiagnosticType dkind, DiagnosticPosition pos, Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) { - return diags.create(dkind, log.currentSource(), pos, - "cant.access.inner.cls.constr", site.tsym.name, argtypes, site.getEnclosingType()); - } - }; - } - - @Override - ReferenceKind referenceKind(Symbol sym) { - return site.getEnclosingType().hasTag(NONE) ? - ReferenceKind.TOPLEVEL : ReferenceKind.IMPLICIT_INNER; - } - } - - /** - * Resolution step for member reference. This generalizes a standard - * method/constructor lookup - on each overload resolution step, a - * lookup helper class is used to perform the reference lookup; at the end - * of the lookup, the helper is used to validate the results. - */ - Symbol findMemberReference(Env<AttrContext> env, LookupHelper lookupHelper) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = new MethodResolutionContext(); - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= ERRONEOUS) { - currentResolutionContext.step = env.info.pendingResolutionPhase = steps.head; - sym = lookupHelper.lookup(env, steps.head); - currentResolutionContext.resolutionCache.put(steps.head, sym); - steps = steps.tail; - } - return lookupHelper.access(env, sym); - } - finally { - currentResolutionContext = prevResolutionContext; - } - } - - /** Resolve constructor. - * @param pos The position to use for error reporting. - * @param env The environment current at the constructor invocation. - * @param site The type of class for which a constructor is searched. - * @param argtypes The types of the constructor invocation's value - * arguments. - * @param typeargtypes The types of the constructor invocation's type - * arguments. - * @param allowBoxing Allow boxing and varargs conversions. - * @param useVarargs Box trailing arguments into an array for varargs. - */ - Symbol resolveConstructor(DiagnosticPosition pos, Env<AttrContext> env, - Type site, List<Type> argtypes, - List<Type> typeargtypes, - boolean allowBoxing, - boolean useVarargs) { - MethodResolutionContext prevResolutionContext = currentResolutionContext; - try { - currentResolutionContext = new MethodResolutionContext(); - return findConstructor(pos, env, site, argtypes, typeargtypes, allowBoxing, useVarargs); - } - finally { - currentResolutionContext = prevResolutionContext; - } - } - - Symbol findConstructor(DiagnosticPosition pos, Env<AttrContext> env, - Type site, List<Type> argtypes, - List<Type> typeargtypes, - boolean allowBoxing, - boolean useVarargs) { - Symbol sym = findMethod(env, site, - names.init, argtypes, - typeargtypes, allowBoxing, - useVarargs, false); - chk.checkDeprecated(pos, env.info.scope.owner, sym); - return sym; - } - - /** Resolve a constructor, throw a fatal error if not found. - * @param pos The position to use for error reporting. - * @param env The environment current at the method invocation. - * @param site The type to be constructed. - * @param argtypes The types of the invocation's value arguments. - * @param typeargtypes The types of the invocation's type arguments. - */ - public MethodSymbol resolveInternalConstructor(DiagnosticPosition pos, Env<AttrContext> env, - Type site, - List<Type> argtypes, - List<Type> typeargtypes) { - MethodResolutionContext resolveContext = new MethodResolutionContext(); - resolveContext.internalResolution = true; - Symbol sym = resolveConstructor(resolveContext, pos, env, site, argtypes, typeargtypes); - if (sym.kind == MTH) return (MethodSymbol)sym; - else throw new FatalError( - diags.fragment("fatal.err.cant.locate.ctor", site)); - } + /** Resolve operator. * @param pos The position to use for error reporting. @@ -2757,6 +2336,350 @@ } /** + * Resolution of member references is typically done as a single + * overload resolution step, where the argument types A are inferred from + * the target functional descriptor. + * + * If the member reference is a method reference with a type qualifier, + * a two-step lookup process is performed. The first step uses the + * expected argument list A, while the second step discards the first + * type from A (which is treated as a receiver type). + * + * There are two cases in which inference is performed: (i) if the member + * reference is a constructor reference and the qualifier type is raw - in + * which case diamond inference is used to infer a parameterization for the + * type qualifier; (ii) if the member reference is an unbound reference + * where the type qualifier is raw - in that case, during the unbound lookup + * the receiver argument type is used to infer an instantiation for the raw + * qualifier type. + * + * When a multi-step resolution process is exploited, it is an error + * if two candidates are found (ambiguity). + * + * This routine returns a pair (T,S), where S is the member reference symbol, + * and T is the type of the class in which S is defined. This is necessary as + * the type T might be dynamically inferred (i.e. if constructor reference + * has a raw qualifier). + */ + Pair<Symbol, ReferenceLookupHelper> resolveMemberReference(DiagnosticPosition pos, + Env<AttrContext> env, + JCMemberReference referenceTree, + Type site, + Name name, List<Type> argtypes, + List<Type> typeargtypes, + boolean boxingAllowed) { + MethodResolutionPhase maxPhase = boxingAllowed ? VARARITY : BASIC; + //step 1 - bound lookup + ReferenceLookupHelper boundLookupHelper = name.equals(names.init) ? + new ConstructorReferenceLookupHelper(referenceTree, site, argtypes, typeargtypes, maxPhase) : + new MethodReferenceLookupHelper(referenceTree, name, site, argtypes, typeargtypes, maxPhase); + Env<AttrContext> boundEnv = env.dup(env.tree, env.info.dup()); + Symbol boundSym = lookupMethod(boundEnv, env.tree.pos(), site.tsym, boundLookupHelper); + + //step 2 - unbound lookup + ReferenceLookupHelper unboundLookupHelper = boundLookupHelper.unboundLookup(); + Env<AttrContext> unboundEnv = env.dup(env.tree, env.info.dup()); + Symbol unboundSym = lookupMethod(unboundEnv, env.tree.pos(), site.tsym, unboundLookupHelper); + + //merge results + Pair<Symbol, ReferenceLookupHelper> res; + if (unboundSym.kind != MTH) { + res = new Pair<Symbol, ReferenceLookupHelper>(boundSym, boundLookupHelper); + env.info.pendingResolutionPhase = boundEnv.info.pendingResolutionPhase; + } else if (boundSym.kind == MTH) { + res = new Pair<Symbol, ReferenceLookupHelper>(ambiguityError(boundSym, unboundSym), boundLookupHelper); + env.info.pendingResolutionPhase = boundEnv.info.pendingResolutionPhase; + } else { + res = new Pair<Symbol, ReferenceLookupHelper>(unboundSym, unboundLookupHelper); + env.info.pendingResolutionPhase = unboundEnv.info.pendingResolutionPhase; + } + + return res; + } + + /** + * Helper for defining custom method-like lookup logic; a lookup helper + * provides hooks for (i) the actual lookup logic and (ii) accessing the + * lookup result (this step might result in compiler diagnostics to be generated) + */ + abstract class LookupHelper { + + /** name of the symbol to lookup */ + Name name; + + /** location in which the lookup takes place */ + Type site; + + /** actual types used during the lookup */ + List<Type> argtypes; + + /** type arguments used during the lookup */ + List<Type> typeargtypes; + + /** Max overload resolution phase handled by this helper */ + MethodResolutionPhase maxPhase; + + LookupHelper(Name name, Type site, List<Type> argtypes, List<Type> typeargtypes, MethodResolutionPhase maxPhase) { + this.name = name; + this.site = site; + this.argtypes = argtypes; + this.typeargtypes = typeargtypes; + this.maxPhase = maxPhase; + } + + /** + * Should lookup stop at given phase with given result + */ + protected boolean shouldStop(Symbol sym, MethodResolutionPhase phase) { + return phase.ordinal() > maxPhase.ordinal() || + sym.kind < ERRONEOUS || sym.kind == AMBIGUOUS; + } + + /** + * Search for a symbol under a given overload resolution phase - this method + * is usually called several times, once per each overload resolution phase + */ + abstract Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase); + + /** + * Validate the result of the lookup + */ + abstract Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym); + } + + abstract class BasicLookupHelper extends LookupHelper { + + BasicLookupHelper(Name name, Type site, List<Type> argtypes, List<Type> typeargtypes) { + super(name, site, argtypes, typeargtypes, MethodResolutionPhase.VARARITY); + } + + @Override + Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) { + if (sym.kind >= AMBIGUOUS) { + //if nothing is found return the 'first' error + sym = accessMethod(sym, pos, location, site, name, true, argtypes, typeargtypes); + } + return sym; + } + } + + /** + * Helper class for member reference lookup. A reference lookup helper + * defines the basic logic for member reference lookup; a method gives + * access to an 'unbound' helper used to perform an unbound member + * reference lookup. + */ + abstract class ReferenceLookupHelper extends LookupHelper { + + /** The member reference tree */ + JCMemberReference referenceTree; + + ReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, + List<Type> argtypes, List<Type> typeargtypes, MethodResolutionPhase maxPhase) { + super(name, site, argtypes, typeargtypes, maxPhase); + this.referenceTree = referenceTree; + + } + + /** + * Returns an unbound version of this lookup helper. By default, this + * method returns an dummy lookup helper. + */ + ReferenceLookupHelper unboundLookup() { + //dummy loopkup helper that always return 'methodNotFound' + return new ReferenceLookupHelper(referenceTree, name, site, argtypes, typeargtypes, maxPhase) { + @Override + ReferenceLookupHelper unboundLookup() { + return this; + } + @Override + Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return methodNotFound; + } + @Override + ReferenceKind referenceKind(Symbol sym) { + Assert.error(); + return null; + } + }; + } + + /** + * Get the kind of the member reference + */ + abstract JCMemberReference.ReferenceKind referenceKind(Symbol sym); + + Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) { + //skip error reporting + return sym; + } + } + + /** + * Helper class for method reference lookup. The lookup logic is based + * upon Resolve.findMethod; in certain cases, this helper class has a + * corresponding unbound helper class (see UnboundMethodReferenceLookupHelper). + * In such cases, non-static lookup results are thrown away. + */ + class MethodReferenceLookupHelper extends ReferenceLookupHelper { + + MethodReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, + List<Type> argtypes, List<Type> typeargtypes, MethodResolutionPhase maxPhase) { + super(referenceTree, name, site, argtypes, typeargtypes, maxPhase); + } + + protected Symbol lookupReferenceInternal(Env<AttrContext> env, MethodResolutionPhase phase) { + return findMethod(env, site, name, argtypes, typeargtypes, + phase.isBoxingRequired(), phase.isVarargsRequired(), syms.operatorNames.contains(name)); + } + + protected Symbol adjustLookupResult(Env<AttrContext> env, Symbol sym) { + return !TreeInfo.isStaticSelector(referenceTree.expr, names) || + sym.kind != MTH || + sym.isStatic() ? sym : new StaticError(sym); + } + + @Override + final Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + return adjustLookupResult(env, lookupReferenceInternal(env, phase)); + } + + @Override + ReferenceLookupHelper unboundLookup() { + if (TreeInfo.isStaticSelector(referenceTree.expr, names) && + argtypes.nonEmpty() && + types.isSubtypeUnchecked(argtypes.head, site)) { + return new UnboundMethodReferenceLookupHelper(referenceTree, name, + site, argtypes, typeargtypes, maxPhase); + } else { + return super.unboundLookup(); + } + } + + @Override + ReferenceKind referenceKind(Symbol sym) { + if (sym.isStatic()) { + return TreeInfo.isStaticSelector(referenceTree.expr, names) ? + ReferenceKind.STATIC : ReferenceKind.STATIC_EVAL; + } else { + Name selName = TreeInfo.name(referenceTree.getQualifierExpression()); + return selName != null && selName == names._super ? + ReferenceKind.SUPER : + ReferenceKind.BOUND; + } + } + } + + /** + * Helper class for unbound method reference lookup. Essentially the same + * as the basic method reference lookup helper; main difference is that static + * lookup results are thrown away. If qualifier type is raw, an attempt to + * infer a parameterized type is made using the first actual argument (that + * would otherwise be ignored during the lookup). + */ + class UnboundMethodReferenceLookupHelper extends MethodReferenceLookupHelper { + + UnboundMethodReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site, + List<Type> argtypes, List<Type> typeargtypes, MethodResolutionPhase maxPhase) { + super(referenceTree, name, + site.isRaw() ? types.asSuper(argtypes.head, site.tsym) : site, + argtypes.tail, typeargtypes, maxPhase); + } + + @Override + protected Symbol adjustLookupResult(Env<AttrContext> env, Symbol sym) { + return sym.kind != MTH || !sym.isStatic() ? sym : new StaticError(sym); + } + + @Override + ReferenceLookupHelper unboundLookup() { + return this; + } + + @Override + ReferenceKind referenceKind(Symbol sym) { + return ReferenceKind.UNBOUND; + } + } + + /** + * Helper class for constructor reference lookup. The lookup logic is based + * upon either Resolve.findMethod or Resolve.findDiamond - depending on + * whether the constructor reference needs diamond inference (this is the case + * if the qualifier type is raw). A special erroneous symbol is returned + * if the lookup returns the constructor of an inner class and there's no + * enclosing instance in scope. + */ + class ConstructorReferenceLookupHelper extends ReferenceLookupHelper { + + boolean needsInference; + + ConstructorReferenceLookupHelper(JCMemberReference referenceTree, Type site, List<Type> argtypes, + List<Type> typeargtypes, MethodResolutionPhase maxPhase) { + super(referenceTree, names.init, site, argtypes, typeargtypes, maxPhase); + if (site.isRaw()) { + this.site = new ClassType(site.getEnclosingType(), site.tsym.type.getTypeArguments(), site.tsym); + needsInference = true; + } + } + + @Override + protected Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) { + Symbol sym = needsInference ? + findDiamond(env, site, argtypes, typeargtypes, phase.isBoxingRequired(), phase.isVarargsRequired()) : + findMethod(env, site, name, argtypes, typeargtypes, + phase.isBoxingRequired(), phase.isVarargsRequired(), syms.operatorNames.contains(name)); + return sym.kind != MTH || + site.getEnclosingType().hasTag(NONE) || + hasEnclosingInstance(env, site) ? + sym : new InvalidSymbolError(Kinds.MISSING_ENCL, sym, null) { + @Override + JCDiagnostic getDiagnostic(DiagnosticType dkind, DiagnosticPosition pos, Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) { + return diags.create(dkind, log.currentSource(), pos, + "cant.access.inner.cls.constr", site.tsym.name, argtypes, site.getEnclosingType()); + } + }; + } + + @Override + ReferenceKind referenceKind(Symbol sym) { + return site.getEnclosingType().hasTag(NONE) ? + ReferenceKind.TOPLEVEL : ReferenceKind.IMPLICIT_INNER; + } + } + + /** + * Main overload resolution routine. On each overload resolution step, a + * lookup helper class is used to perform the method/constructor lookup; + * at the end of the lookup, the helper is used to validate the results + * (this last step might trigger overload resolution diagnostics). + */ + Symbol lookupMethod(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, LookupHelper lookupHelper) { + return lookupMethod(env, pos, location, new MethodResolutionContext(), lookupHelper); + } + + Symbol lookupMethod(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, + MethodResolutionContext resolveContext, LookupHelper lookupHelper) { + MethodResolutionContext prevResolutionContext = currentResolutionContext; + try { + Symbol bestSoFar = methodNotFound; + currentResolutionContext = resolveContext; + for (MethodResolutionPhase phase : methodResolutionSteps) { + if (!phase.isApplicable(boxingEnabled, varargsEnabled) || + lookupHelper.shouldStop(bestSoFar, phase)) break; + MethodResolutionPhase prevPhase = currentResolutionContext.step; + Symbol prevBest = bestSoFar; + currentResolutionContext.step = phase; + bestSoFar = phase.mergeResults(bestSoFar, lookupHelper.lookup(env, phase)); + env.info.pendingResolutionPhase = (prevBest == bestSoFar) ? prevPhase : phase; + } + return lookupHelper.access(env, pos, location, bestSoFar); + } finally { + currentResolutionContext = prevResolutionContext; + } + } + + /** * Resolve `c.name' where name == this or name == super. * @param pos The position to use for error reporting. * @param env The environment current at the expression. @@ -3190,20 +3113,14 @@ return types.createErrorType(name, location, syms.errSymbol.type).tsym; } - protected boolean shouldReport(Candidate c) { - MethodResolutionPhase errPhase = resolveContext.firstErroneousResolutionPhase(); - return !c.isApplicable() && - c.step == errPhase; - } - private Candidate errCandidate() { + Candidate bestSoFar = null; for (Candidate c : resolveContext.candidates) { - if (shouldReport(c)) { - return c; - } + if (c.isApplicable()) continue; + bestSoFar = c; } - Assert.error(); - return null; + Assert.checkNonNull(bestSoFar); + return bestSoFar; } } @@ -3232,7 +3149,7 @@ pos, "cant.apply.symbols", name == names.init ? KindName.CONSTRUCTOR : absentKind(kind), - getName(), + name == names.init ? site.tsym.name : name, argtypes); return new JCDiagnostic.MultilineDiagnostic(err, candidateDetails(site)); } else { @@ -3243,24 +3160,17 @@ //where List<JCDiagnostic> candidateDetails(Type site) { - List<JCDiagnostic> details = List.nil(); + Map<Symbol, JCDiagnostic> details = new LinkedHashMap<Symbol, JCDiagnostic>(); for (Candidate c : resolveContext.candidates) { - if (!shouldReport(c)) continue; + if (c.isApplicable()) continue; JCDiagnostic detailDiag = diags.fragment("inapplicable.method", Kinds.kindName(c.sym), c.sym.location(site, types), c.sym.asMemberOf(site, types), c.details); - details = details.prepend(detailDiag); + details.put(c.sym, detailDiag); } - return details.reverse(); - } - - private Name getName() { - Symbol sym = resolveContext.candidates.head.sym; - return sym.name == names.init ? - sym.owner.name : - sym.name; + return List.from(details.values()); } } @@ -3398,7 +3308,21 @@ enum MethodResolutionPhase { BASIC(false, false), BOX(true, false), - VARARITY(true, true); + VARARITY(true, true) { + @Override + public Symbol mergeResults(Symbol bestSoFar, Symbol sym) { + switch (sym.kind) { + case WRONG_MTH: + return (bestSoFar.kind == WRONG_MTH || bestSoFar.kind == WRONG_MTHS) ? + bestSoFar : + sym; + case ABSENT_MTH: + return bestSoFar; + default: + return sym; + } + } + }; boolean isBoxingRequired; boolean isVarargsRequired; @@ -3420,6 +3344,10 @@ return (varargsEnabled || !isVarargsRequired) && (boxingEnabled || !isBoxingRequired); } + + public Symbol mergeResults(Symbol prev, Symbol sym) { + return sym; + } } final List<MethodResolutionPhase> methodResolutionSteps = List.of(BASIC, BOX, VARARITY); @@ -3435,29 +3363,11 @@ private List<Candidate> candidates = List.nil(); - private Map<MethodResolutionPhase, Symbol> resolutionCache = - new EnumMap<MethodResolutionPhase, Symbol>(MethodResolutionPhase.class); - MethodResolutionPhase step = null; private boolean internalResolution = false; private DeferredAttr.AttrMode attrMode = DeferredAttr.AttrMode.SPECULATIVE; - private MethodResolutionPhase firstErroneousResolutionPhase() { - MethodResolutionPhase bestSoFar = BASIC; - Symbol sym = methodNotFound; - List<MethodResolutionPhase> steps = methodResolutionSteps; - while (steps.nonEmpty() && - steps.head.isApplicable(boxingEnabled, varargsEnabled) && - sym.kind >= WRONG_MTHS) { - sym = resolutionCache.get(steps.head); - if (sym.kind == ABSENT_MTH) break; //ignore spurious empty entries - bestSoFar = steps.head; - steps = steps.tail; - } - return bestSoFar; - } - void addInapplicableCandidate(Symbol sym, JCDiagnostic details) { Candidate c = new Candidate(currentResolutionContext.step, sym, details, null); candidates = candidates.append(c); @@ -3468,16 +3378,6 @@ candidates = candidates.append(c); } - Candidate getCandidate(Symbol sym, MethodResolutionPhase phase) { - for (Candidate c : currentResolutionContext.candidates) { - if (c.step == phase && - c.sym.baseSymbol() == sym.baseSymbol()) { - return c; - } - } - return null; - } - /** * This class represents an overload resolution candidate. There are two * kinds of candidates: applicable methods and inapplicable methods;
--- a/test/tools/javac/7132880/T7132880.out Sun Nov 04 10:59:42 2012 +0000 +++ b/test/tools/javac/7132880/T7132880.out Sun Nov 04 11:01:49 2012 +0000 @@ -1,4 +1,4 @@ T7132880.java:23:12: compiler.err.cant.apply.symbol: kindname.method, m1, java.lang.Integer, java.lang.String, kindname.class, Outer.Inner1, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, java.lang.Integer)) -T7132880.java:33:12: compiler.err.cant.apply.symbols: kindname.method, m1, java.lang.String,{(compiler.misc.inapplicable.method: kindname.method, Outer.Inner2, m1(java.lang.Double), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, java.lang.Double))),(compiler.misc.inapplicable.method: kindname.method, Outer.Inner2, m1(java.lang.Integer), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, java.lang.Integer)))} +T7132880.java:33:12: compiler.err.cant.apply.symbols: kindname.method, m1, java.lang.String,{(compiler.misc.inapplicable.method: kindname.method, Outer.Inner2, m1(java.lang.Integer), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, java.lang.Integer))),(compiler.misc.inapplicable.method: kindname.method, Outer.Inner2, m1(java.lang.Double), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, java.lang.Double)))} T7132880.java:43:12: compiler.err.ref.ambiguous: m2, kindname.method, m2(java.lang.Object,int), Outer.Inner3, kindname.method, m2(int,java.lang.Object), Outer.Inner3 3 errors
--- a/test/tools/javac/Diagnostics/6799605/T6799605.out Sun Nov 04 10:59:42 2012 +0000 +++ b/test/tools/javac/Diagnostics/6799605/T6799605.out Sun Nov 04 11:01:49 2012 +0000 @@ -1,4 +1,4 @@ -T6799605.java:17:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.inferred.do.not.conform.to.upper.bounds: compiler.misc.type.captureof: 1, ?, T6799605<compiler.misc.type.captureof: 1, ?>))} -T6799605.java:18:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 2, ?, compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))} -T6799605.java:19:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,T6799605<compiler.misc.type.captureof: 3, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 3, ?, compiler.misc.type.captureof: 3, ?,compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))} +T6799605.java:17:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.inferred.do.not.conform.to.upper.bounds: compiler.misc.type.captureof: 1, ?, T6799605<compiler.misc.type.captureof: 1, ?>)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))} +T6799605.java:18:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 2, ?, compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T))} +T6799605.java:19:9: compiler.err.cant.apply.symbols: kindname.method, m, T6799605<compiler.misc.type.captureof: 1, ?>,T6799605<compiler.misc.type.captureof: 2, ?>,T6799605<compiler.misc.type.captureof: 3, ?>,{(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.method, T6799605, <T>m(T6799605<T>,T6799605<T>,T6799605<T>), (compiler.misc.inferred.do.not.conform.to.eq.bounds: compiler.misc.type.captureof: 3, ?, compiler.misc.type.captureof: 3, ?,compiler.misc.type.captureof: 2, ?,compiler.misc.type.captureof: 1, ?))} 3 errors
--- a/test/tools/javac/defaultMethods/Neg12.out Sun Nov 04 10:59:42 2012 +0000 +++ b/test/tools/javac/defaultMethods/Neg12.out Sun Nov 04 11:01:49 2012 +0000 @@ -1,4 +1,4 @@ Neg12.java:21:12: compiler.err.does.not.override.abstract: Neg12.D, m(java.lang.String), Neg12.I2 -Neg12.java:24:10: compiler.err.cant.apply.symbols: kindname.method, m, ,{(compiler.misc.inapplicable.method: kindname.method, Neg12.B, m(java.lang.Integer), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, Neg12.I1, m(java.lang.String), (compiler.misc.arg.length.mismatch))} +Neg12.java:24:10: compiler.err.cant.apply.symbols: kindname.method, m, ,{(compiler.misc.inapplicable.method: kindname.method, Neg12.I1, m(java.lang.String), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, Neg12.B, m(java.lang.Integer), (compiler.misc.arg.length.mismatch))} Neg12.java:25:10: compiler.err.cant.apply.symbol: kindname.method, m, java.lang.Integer, compiler.misc.no.args, kindname.class, Neg12.B, (compiler.misc.arg.length.mismatch) 3 errors
--- a/test/tools/javac/generics/inference/6611449/T6611449.out Sun Nov 04 10:59:42 2012 +0000 +++ b/test/tools/javac/generics/inference/6611449/T6611449.out Sun Nov 04 11:01:49 2012 +0000 @@ -1,5 +1,5 @@ -T6611449.java:18:9: compiler.err.cant.apply.symbols: kindname.constructor, T6611449, int,{(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T,T), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S))} -T6611449.java:19:9: compiler.err.cant.apply.symbols: kindname.constructor, T6611449, int,int,{(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T,T), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S)),(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T), (compiler.misc.infer.arg.length.mismatch: T))} +T6611449.java:18:9: compiler.err.cant.apply.symbols: kindname.constructor, T6611449, int,{(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S)),(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T,T), (compiler.misc.infer.arg.length.mismatch: T))} +T6611449.java:19:9: compiler.err.cant.apply.symbols: kindname.constructor, T6611449, int,int,{(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T), (compiler.misc.infer.arg.length.mismatch: T)),(compiler.misc.inapplicable.method: kindname.constructor, T6611449, <T>T6611449(T,T), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S))} T6611449.java:20:9: compiler.err.cant.apply.symbol: kindname.method, m1, T, int, kindname.class, T6611449<S>, (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S) T6611449.java:21:9: compiler.err.cant.apply.symbol: kindname.method, m2, T,T, int,int, kindname.class, T6611449<S>, (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.Integer, S) 4 errors
--- a/test/tools/javac/generics/inference/7086601/T7086601a.out Sun Nov 04 10:59:42 2012 +0000 +++ b/test/tools/javac/generics/inference/7086601/T7086601a.out Sun Nov 04 11:01:49 2012 +0000 @@ -1,5 +1,5 @@ -T7086601a.java:20:9: compiler.err.cant.apply.symbols: kindname.method, m1, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, m1(java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m1(java.lang.Iterable<? super S>,java.lang.Iterable<? super S>), (compiler.misc.incompatible.upper.bounds: S, java.lang.Integer,java.lang.String,java.lang.Object))} -T7086601a.java:24:9: compiler.err.cant.apply.symbols: kindname.method, m2, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,java.lang.Iterable<java.lang.Double>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, m2(java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m2(java.lang.Iterable<? super S>,java.lang.Iterable<? super S>,java.lang.Iterable<? super S>), (compiler.misc.incompatible.upper.bounds: S, java.lang.Double,java.lang.Integer,java.lang.String,java.lang.Object))} -T7086601a.java:28:9: compiler.err.cant.apply.symbols: kindname.method, m3, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, m3(java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m3(java.lang.Iterable<? super S>...), (compiler.misc.incompatible.upper.bounds: S, java.lang.Integer,java.lang.String,java.lang.Object))} -T7086601a.java:32:9: compiler.err.cant.apply.symbols: kindname.method, m3, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,java.lang.Iterable<java.lang.Double>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, m3(java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m3(java.lang.Iterable<? super S>...), (compiler.misc.incompatible.upper.bounds: S, java.lang.Double,java.lang.Integer,java.lang.String,java.lang.Object))} +T7086601a.java:20:9: compiler.err.cant.apply.symbols: kindname.method, m1, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m1(java.lang.Iterable<? super S>,java.lang.Iterable<? super S>), (compiler.misc.incompatible.upper.bounds: S, java.lang.Integer,java.lang.String,java.lang.Object)),(compiler.misc.inapplicable.method: kindname.method, T7086601, m1(java.lang.Object), (compiler.misc.arg.length.mismatch))} +T7086601a.java:24:9: compiler.err.cant.apply.symbols: kindname.method, m2, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,java.lang.Iterable<java.lang.Double>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m2(java.lang.Iterable<? super S>,java.lang.Iterable<? super S>,java.lang.Iterable<? super S>), (compiler.misc.incompatible.upper.bounds: S, java.lang.Double,java.lang.Integer,java.lang.String,java.lang.Object)),(compiler.misc.inapplicable.method: kindname.method, T7086601, m2(java.lang.Object), (compiler.misc.arg.length.mismatch))} +T7086601a.java:28:9: compiler.err.cant.apply.symbols: kindname.method, m3, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m3(java.lang.Iterable<? super S>...), (compiler.misc.incompatible.upper.bounds: S, java.lang.Integer,java.lang.String,java.lang.Object)),(compiler.misc.inapplicable.method: kindname.method, T7086601, m3(java.lang.Object), (compiler.misc.arg.length.mismatch))} +T7086601a.java:32:9: compiler.err.cant.apply.symbols: kindname.method, m3, java.lang.Iterable<java.lang.String>,java.lang.Iterable<java.lang.Integer>,java.lang.Iterable<java.lang.Double>,{(compiler.misc.inapplicable.method: kindname.method, T7086601, <S>m3(java.lang.Iterable<? super S>...), (compiler.misc.incompatible.upper.bounds: S, java.lang.Double,java.lang.Integer,java.lang.String,java.lang.Object)),(compiler.misc.inapplicable.method: kindname.method, T7086601, m3(java.lang.Object), (compiler.misc.arg.length.mismatch))} 4 errors
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/resolve/tests/AmbiguityPrecedence.java Sun Nov 04 11:01:49 2012 +0000 @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +@TraceResolve(keys={"compiler.err.ref.ambiguous"}) +class AmbiguityPrecedence { + + @Candidate(applicable=Phase.BASIC) + static void m1(long l, int i) {} + @Candidate(applicable=Phase.BASIC) + static void m1(int i, long l) {} + @Candidate + static void m1(Integer i1, Integer i2) {} + + @Candidate(applicable=Phase.BOX) + static void m2(Object o, Integer i) {} + @Candidate(applicable=Phase.BOX) + static void m2(Integer i, Object o) {} + @Candidate + static void m2(Integer... o) {} + + { + m1(1, 1); + m2(1, 1); + } +}