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

-:843d3b191773
+:01c9d4161882
 ((sym.flags() & STATIC) != 0 || sym.kind == TYP || site.tsym.isSubClass(c, types))))
 c = c.owner.enclClass();
 return c != null;
 }
+/**
+* Performs a recursive scan of a type looking for accessibility problems
+* from current attribution environment
+*/
+void checkAccessibleType(Env<AttrContext> env, Type t) {
+accessibilityChecker.visit(t, env);
+}
+/**
+* Accessibility type-visitor
+*/
+Types.SimpleVisitor<Void, Env<AttrContext>> accessibilityChecker =
+new Types.SimpleVisitor<Void, Env<AttrContext>>() {
+void visit(List<Type> ts, Env<AttrContext> env) {
+for (Type t : ts) {
+visit(t, env);
+}
+}
+public Void visitType(Type t, Env<AttrContext> env) {
+return null;
+}
+@Override
+public Void visitArrayType(ArrayType t, Env<AttrContext> env) {
+visit(t.elemtype, env);
+return null;
+}
+@Override
+public Void visitClassType(ClassType t, Env<AttrContext> env) {
+visit(t.getTypeArguments(), env);
+if (!isAccessible(env, t, true)) {
+accessBase(new AccessError(t.tsym), env.tree.pos(), env.enclClass.sym, t, t.tsym.name, true);
+}
+return null;
+}
+@Override
+public Void visitWildcardType(WildcardType t, Env<AttrContext> env) {
+visit(t.type, env);
+return null;
+}
+@Override
+public Void visitMethodType(MethodType t, Env<AttrContext> env) {
+visit(t.getParameterTypes(), env);
+visit(t.getReturnType(), env);
+visit(t.getThrownTypes(), env);
+return null;
+}
+};
 /** Try to instantiate the type of a method so that it fits
 *  given type arguments and argument types. If succesful, return
 *  the method's instantiated type, else return null.
 *  The instantiation will take into account an additional leading
 *  formal parameter if the method is an instance method seen as a member
 }
 public boolean compatible(Type found, Type req, Warner warn) {
 return types.isSubtypeUnchecked(found, inferenceContext.asFree(req, types), warn);
 }
-public boolean allowBoxing() {
-return false;
-}
 }
 /**
 * Subclass of method check context class that implements loose method conversion.
 * Loose method conversion checks compatibility between types using method conversion tests.
 super(handler, useVarargs, inferenceContext, deferredAttrContext, rsWarner);
 }
 public boolean compatible(Type found, Type req, Warner warn) {
 return types.isConvertible(found, inferenceContext.asFree(req, types), warn);
-}
-public boolean allowBoxing() {
-return true;
 }
 }
 /**
 * Create a method check context to be used during method applicability check
 class MethodResultInfo extends ResultInfo {
 DeferredAttr.DeferredAttrContext deferredAttrContext;
-public MethodResultInfo(Type pt, MethodCheckContext checkContext, DeferredAttr.DeferredAttrContext deferredAttrContext) {
+public MethodResultInfo(Type pt, CheckContext checkContext, DeferredAttr.DeferredAttrContext deferredAttrContext) {
 attr.super(VAL, pt, checkContext);
 this.deferredAttrContext = deferredAttrContext;
 }
 @Override
 }
 }
 @Override
 protected MethodResultInfo dup(Type newPt) {
-return new MethodResultInfo(newPt, (MethodCheckContext)checkContext, deferredAttrContext);
+return new MethodResultInfo(newPt, checkContext, deferredAttrContext);
+}
+@Override
+protected ResultInfo dup(CheckContext newContext) {
+return new MethodResultInfo(pt, newContext, deferredAttrContext);
 }
 }
 public static class InapplicableMethodException extends RuntimeException {
 private static final long serialVersionUID = 0;
 return bestSoFar;
 }
 Assert.check(sym.kind < AMBIGUOUS);
 try {
 Type mt = rawInstantiate(env, site, sym, null, argtypes, typeargtypes,
-allowBoxing, useVarargs, Warner.noWarnings);
+allowBoxing, useVarargs, types.noWarnings);
 if (!operator)
 currentResolutionContext.addApplicableCandidate(sym, mt);
 } catch (InapplicableMethodException ex) {
 if (!operator)
 currentResolutionContext.addInapplicableCandidate(sym, ex.getDiagnostic());
 return !site.isErroneous() &&
 !Type.isErroneous(argtypes) &&
 (typeargtypes == null || !Type.isErroneous(typeargtypes));
 }
 public List<Type> getArgumentTypes(ResolveError errSym, Symbol accessedSym, Name name, List<Type> argtypes) {
-if (syms.operatorNames.contains(name)) {
+return (syms.operatorNames.contains(name)) ?
-return argtypes;
+argtypes :
-} else {
+Type.map(argtypes, new ResolveDeferredRecoveryMap(accessedSym));
-Symbol msym = errSym.kind == WRONG_MTH ?
+}
-((InapplicableSymbolError)errSym).errCandidate().sym : accessedSym;
+class ResolveDeferredRecoveryMap extends DeferredAttr.RecoveryDeferredTypeMap {
-List<Type> argtypes2 = Type.map(argtypes,
-deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, msym, currentResolutionContext.step));
+public ResolveDeferredRecoveryMap(Symbol msym) {
+deferredAttr.super(AttrMode.SPECULATIVE, msym, currentResolutionContext.step);
-if (msym != accessedSym) {
+}
-//fixup deferred type caches - this 'hack' is required because the symbol
-//returned by InapplicableSymbolError.access() will hide the candidate
+@Override
-//method symbol that can be used for lookups in the speculative cache,
+protected Type typeOf(DeferredType dt) {
-//causing problems in Attr.checkId()
+Type res = super.typeOf(dt);
-for (Type t : argtypes) {
+if (!res.isErroneous()) {
-if (t.hasTag(DEFERRED)) {
+switch (TreeInfo.skipParens(dt.tree).getTag()) {
-DeferredType dt = (DeferredType)t;
+case LAMBDA:
-dt.speculativeCache.dupAllTo(msym, accessedSym);
+case REFERENCE:
-}
+return dt;
+case CONDEXPR:
+return res == Type.recoveryType ?
+dt : res;
 }
 }
-return argtypes2;
+return res;
 }
 }
 };
 /** Check that sym is not an abstract method.
 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;
 }
 *  @param env       Attribution environment
 *  @param spMethod  signature polymorphic method - i.e. MH.invokeExact
 *  @param argtypes  The required argument types
 */
 Symbol findPolymorphicSignatureInstance(Env<AttrContext> env,
-Symbol spMethod,
+final Symbol spMethod,
 List<Type> argtypes) {
 Type mtype = infer.instantiatePolymorphicSignatureInstance(env,
 (MethodSymbol)spMethod, currentResolutionContext, argtypes);
 for (Symbol sym : polymorphicSignatureScope.getElementsByName(spMethod.name)) {
 if (types.isSameType(mtype, sym.type)) {
 }
 }
 // create the desired method
 long flags = ABSTRACT | HYPOTHETICAL | spMethod.flags() & Flags.AccessFlags;
-Symbol msym = new MethodSymbol(flags, spMethod.name, mtype, spMethod.owner);
+Symbol msym = new MethodSymbol(flags, spMethod.name, mtype, spMethod.owner) {
+@Override
+public Symbol baseSymbol() {
+return spMethod;
+}
+};
 polymorphicSignatureScope.enter(msym);
 return msym;
 }
 /** Resolve a qualified method identifier, throw a fatal error if not
 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
 env1 = env1.outer;
 }
 if (allowDefaultMethods && c.isInterface() &&
 name == names._super && !isStatic(env) &&
-types.isDirectSuperInterface(c.type, env.enclClass.sym)) {
+types.isDirectSuperInterface(c, env.enclClass.sym)) {
 //this might be a default super call if one of the superinterfaces is 'c'
 for (Type t : pruneInterfaces(env.enclClass.type)) {
 if (t.tsym == c) {
 env.info.defaultSuperCallSite = t;
 return new VarSymbol(0, names._super,
 log.currentSource(),
 pos,
 "cant.apply.symbols",
 name == names.init ? KindName.CONSTRUCTOR : absentKind(kind),
 name == names.init ? site.tsym.name : name,
-argtypes);
+methodArguments(argtypes));
 return new JCDiagnostic.MultilineDiagnostic(err, candidateDetails(site));
 } else {
 return new SymbolNotFoundError(ABSENT_MTH).getDiagnostic(dkind, pos,
 location, site, name, argtypes, typeargtypes);
 }

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