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

-:5e54a59bcee7
+:a23e1dc02698
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.tree.*;
+import static com.sun.tools.javac.comp.Resolve.MethodResolutionPhase.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTags.*;
 import javax.lang.model.element.ElementVisitor;
+import java.util.Map;
+import java.util.HashMap;
 /** Helper class for name resolution, used mostly by the attribution phase.
 *
 *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
 *  you write code that depends on this, you do so at your own risk.
 Symbol resolveMethod(DiagnosticPosition pos,
 Env<AttrContext> env,
 Name name,
 List<Type> argtypes,
 List<Type> typeargtypes) {
-Symbol sym = findFun(env, name, argtypes, typeargtypes, false, env.info.varArgs=false);
+Symbol sym = methodNotFound;
-if (varargsEnabled && sym.kind >= WRONG_MTHS) {
+List<MethodResolutionPhase> steps = methodResolutionSteps;
-sym = findFun(env, name, argtypes, typeargtypes, true, false);
+while (steps.nonEmpty() &&
-if (sym.kind >= WRONG_MTHS)
+steps.head.isApplicable(boxingEnabled, varargsEnabled) &&
-sym = findFun(env, name, argtypes, typeargtypes, true, env.info.varArgs=true);
+sym.kind >= ERRONEOUS) {
-}
+sym = findFun(env, name, argtypes, typeargtypes,
-if (sym.kind >= AMBIGUOUS) {
+steps.head.isBoxingRequired,
-sym = access(
+env.info.varArgs = steps.head.isVarargsRequired);
-sym, pos, env.enclClass.sym.type, name, false, argtypes, typeargtypes);
+methodResolutionCache.put(steps.head, sym);
+steps = steps.tail;
+}
+if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
+MethodResolutionPhase errPhase =
+firstErroneousResolutionPhase();
+sym = access(methodResolutionCache.get(errPhase),
+pos, env.enclClass.sym.type, name, false, argtypes, typeargtypes);
+env.info.varArgs = errPhase.isVarargsRequired;
 }
 return sym;
 }
 /** Resolve a qualified method identifier
 *  @param typeargtypes  The types of the invocation's type arguments.
 */
 Symbol resolveQualifiedMethod(DiagnosticPosition pos, Env<AttrContext> env,
 Type site, Name name, List<Type> argtypes,
 List<Type> typeargtypes) {
-Symbol sym = findMethod(env, site, name, argtypes, typeargtypes, false,
+Symbol sym = methodNotFound;
-env.info.varArgs=false, false);
+List<MethodResolutionPhase> steps = methodResolutionSteps;
-if (varargsEnabled && sym.kind >= WRONG_MTHS) {
+while (steps.nonEmpty() &&
-sym = findMethod(env, site, name, argtypes, typeargtypes, true,
+steps.head.isApplicable(boxingEnabled, varargsEnabled) &&
-false, false);
+sym.kind >= ERRONEOUS) {
-if (sym.kind >= WRONG_MTHS)
+sym = findMethod(env, site, name, argtypes, typeargtypes,
-sym = findMethod(env, site, name, argtypes, typeargtypes, true,
+steps.head.isBoxingRequired(),
-env.info.varArgs=true, false);
+env.info.varArgs = steps.head.isVarargsRequired(), false);
-}
+methodResolutionCache.put(steps.head, sym);
-if (sym.kind >= AMBIGUOUS) {
+steps = steps.tail;
-sym = access(sym, pos, site, name, true, argtypes, typeargtypes);
+}
+if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
+MethodResolutionPhase errPhase =
+firstErroneousResolutionPhase();
+sym = access(methodResolutionCache.get(errPhase),
+pos, site, name, true, argtypes, typeargtypes);
+env.info.varArgs = errPhase.isVarargsRequired;
 }
 return sym;
 }
 /** Resolve a qualified method identifier, throw a fatal error if not
 Symbol resolveConstructor(DiagnosticPosition pos,
 Env<AttrContext> env,
 Type site,
 List<Type> argtypes,
 List<Type> typeargtypes) {
-Symbol sym = resolveConstructor(pos, env, site, argtypes, typeargtypes, false, env.info.varArgs=false);
+Symbol sym = methodNotFound;
-if (varargsEnabled && sym.kind >= WRONG_MTHS) {
+List<MethodResolutionPhase> steps = methodResolutionSteps;
-sym = resolveConstructor(pos, env, site, argtypes, typeargtypes, true, false);
+while (steps.nonEmpty() &&
-if (sym.kind >= WRONG_MTHS)
+steps.head.isApplicable(boxingEnabled, varargsEnabled) &&
-sym = resolveConstructor(pos, env, site, argtypes, typeargtypes, true, env.info.varArgs=true);
+sym.kind >= ERRONEOUS) {
-}
+sym = resolveConstructor(pos, env, site, argtypes, typeargtypes,
-if (sym.kind >= AMBIGUOUS) {
+steps.head.isBoxingRequired(),
-sym = access(sym, pos, site, names.init, true, argtypes, typeargtypes);
+env.info.varArgs = steps.head.isVarargsRequired());
+methodResolutionCache.put(steps.head, sym);
+steps = steps.tail;
+}
+if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
+MethodResolutionPhase errPhase = firstErroneousResolutionPhase();
+sym = access(methodResolutionCache.get(errPhase),
+pos, site, names.init, true, argtypes, typeargtypes);
+env.info.varArgs = errPhase.isVarargsRequired();
 }
 return sym;
 }
 /** Resolve constructor.
 kindName(pair.sym2),
 pair.sym2,
 pair.sym2.location(site, types));
 }
 }
+enum MethodResolutionPhase {
+BASIC(false, false),
+BOX(true, false),
+VARARITY(true, true);
+boolean isBoxingRequired;
+boolean isVarargsRequired;
+MethodResolutionPhase(boolean isBoxingRequired, boolean isVarargsRequired) {
+this.isBoxingRequired = isBoxingRequired;
+this.isVarargsRequired = isVarargsRequired;
+}
+public boolean isBoxingRequired() {
+return isBoxingRequired;
+}
+public boolean isVarargsRequired() {
+return isVarargsRequired;
+}
+public boolean isApplicable(boolean boxingEnabled, boolean varargsEnabled) {
+return (varargsEnabled || !isVarargsRequired) &&
+(boxingEnabled || !isBoxingRequired);
+}
+}
+private Map<MethodResolutionPhase, Symbol> methodResolutionCache =
+new HashMap<MethodResolutionPhase, Symbol>(MethodResolutionPhase.values().length);
+final List<MethodResolutionPhase> methodResolutionSteps = List.of(BASIC, BOX, VARARITY);
+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 = methodResolutionCache.get(steps.head);
+bestSoFar = steps.head;
+steps = steps.tail;
+}
+return bestSoFar;
+}
 }

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