< prev index next > src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
Print this page
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.DefinedBy.Api;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticType;
- import com.sun.tools.javac.util.JCDiagnostic.Warning;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
- import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
if (env.info.visitingServiceImplementation &&
env.toplevel.modle == sym.packge().modle) {
return true;
}
- switch ((short)(sym.flags() & AccessFlags)) {
- case PRIVATE:
- return
- (env.enclClass.sym == sym.owner // fast special case
- ||
- env.enclClass.sym.outermostClass() ==
- sym.owner.outermostClass())
- &&
- sym.isInheritedIn(site.tsym, types);
- case 0:
- return
- (env.toplevel.packge == sym.owner.owner // fast special case
- ||
- env.toplevel.packge == sym.packge())
- &&
- isAccessible(env, site, checkInner)
- &&
- sym.isInheritedIn(site.tsym, types)
- &&
- notOverriddenIn(site, sym);
- case PROTECTED:
- return
- (env.toplevel.packge == sym.owner.owner // fast special case
- ||
- env.toplevel.packge == sym.packge()
- ||
- isProtectedAccessible(sym, env.enclClass.sym, site)
- ||
- // OK to select instance method or field from 'super' or type name
- // (but type names should be disallowed elsewhere!)
- env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)
- &&
- isAccessible(env, site, checkInner)
- &&
- notOverriddenIn(site, sym);
- default: // this case includes erroneous combinations as well
- return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);
+ ClassSymbol enclosingCsym = env.enclClass.sym;
+ if (sym.kind == MTH || sym.kind == VAR) {
+ /* If any primitive class types are involved, ask the same question in the reference universe,
+ where the hierarchy is navigable
+ */
+ if (site.isPrimitiveClass())
+ site = site.referenceProjection();
+ } else if (sym.kind == TYP) {
+ // A type is accessible in a reference projection if it was
+ // accessible in the value projection.
+ if (site.isReferenceProjection())
+ site = site.asValueType();
+ }
+ try {
+ switch ((short)(sym.flags() & AccessFlags)) {
+ case PRIVATE:
+ return
+ (env.enclClass.sym == sym.owner // fast special case
+ ||
+ env.enclClass.sym.outermostClass() ==
+ sym.owner.outermostClass())
+ &&
+ sym.isInheritedIn(site.tsym, types);
+ case 0:
+ return
+ (env.toplevel.packge == sym.owner.owner // fast special case
+ ||
+ env.toplevel.packge == sym.packge())
+ &&
+ isAccessible(env, site, checkInner)
+ &&
+ sym.isInheritedIn(site.tsym, types)
+ &&
+ notOverriddenIn(site, sym);
+ case PROTECTED:
+ return
+ (env.toplevel.packge == sym.owner.owner // fast special case
+ ||
+ env.toplevel.packge == sym.packge()
+ ||
+ isProtectedAccessible(sym, env.enclClass.sym, site)
+ ||
+ // OK to select instance method or field from 'super' or type name
+ // (but type names should be disallowed elsewhere!)
+ env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)
+ &&
+ isAccessible(env, site, checkInner)
+ &&
+ notOverriddenIn(site, sym);
+ default: // this case includes erroneous combinations as well
+ return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);
+ }
+ } finally {
+ env.enclClass.sym = enclosingCsym;
}
}
//where
/* `sym' is accessible only if not overridden by
* another symbol which is a member of `site'
* cannot be overridden (e.g. MH.invokeExact(Object[])).
*/
private boolean notOverriddenIn(Type site, Symbol sym) {
if (sym.kind != MTH || sym.isConstructor() || sym.isStatic())
return true;
- else {
- Symbol s2 = ((MethodSymbol)sym).implementation(site.tsym, types, true);
- return (s2 == null || s2 == sym || sym.owner == s2.owner || (sym.owner.isInterface() && s2.owner == syms.objectType.tsym) ||
- !types.isSubSignature(types.memberType(site, s2), types.memberType(site, sym)));
- }
+
+ /* If any primitive class types are involved, ask the same question in the reference universe,
+ where the hierarchy is navigable
+ */
+ if (site.isPrimitiveClass())
+ site = site.referenceProjection();
+
+ Symbol s2 = ((MethodSymbol)sym).implementation(site.tsym, types, true);
+ return (s2 == null || s2 == sym || sym.owner == s2.owner || (sym.owner.isInterface() && s2.owner == syms.objectType.tsym) ||
+ !types.isSubSignature(types.memberType(site, s2), types.memberType(site, sym)));
}
//where
/** Is given protected symbol accessible if it is selected from given site
* and the selection takes place in given class?
* @param sym The symbol with protected access
TypeSymbol m2Owner = (TypeSymbol)m2.owner;
// the two owners can never be the same if the target methods are compiled from source,
// but we need to protect against cases where the methods are defined in some classfile
// and make sure we issue an ambiguity error accordingly (by skipping the logic below).
if (m1Owner != m2Owner) {
- if (types.asSuper(m1Owner.type, m2Owner) != null &&
+ if (types.asSuper(m1Owner.type.referenceProjectionOrSelf(), m2Owner) != null &&
((m1.owner.flags_field & INTERFACE) == 0 ||
(m2.owner.flags_field & INTERFACE) != 0) &&
m1.overrides(m2, m1Owner, types, false))
return m1;
- if (types.asSuper(m2Owner.type, m1Owner) != null &&
+ if (types.asSuper(m2Owner.type.referenceProjectionOrSelf(), m1Owner) != null &&
((m2.owner.flags_field & INTERFACE) == 0 ||
(m1.owner.flags_field & INTERFACE) != 0) &&
m2.overrides(m1, m2Owner, types, false))
return m2;
}
*/
Symbol findMemberType(Env<AttrContext> env,
Type site,
Name name,
TypeSymbol c) {
+ return findMemberTypeInternal(env,site, name, c);
+ }
+
+ /** Find qualified member type.
+ * @param env The current environment.
+ * @param site The original type from where the selection takes
+ * place.
+ * @param name The type's name.
+ * @param c The class to search for the member type. This is
+ * always a superclass or implemented interface of
+ * site's class.
+ */
+ Symbol findMemberTypeInternal(Env<AttrContext> env,
+ Type site,
+ Name name,
+ TypeSymbol c) {
Symbol sym = findImmediateMemberType(env, site, name, c);
if (sym != typeNotFound)
return sym;
/** Find an unqualified type symbol.
* @param env The current environment.
* @param name The type's name.
*/
Symbol findType(Env<AttrContext> env, Name name) {
+ return findTypeInternal(env, name);
+ }
+
+ /** Find an unqualified type symbol.
+ * @param env The current environment.
+ * @param name The type's name.
+ */
+ Symbol findTypeInternal(Env<AttrContext> env, Name name) {
if (name == names.empty)
return typeNotFound; // do not allow inadvertent "lookup" of anonymous types
Symbol bestSoFar = typeNotFound;
Symbol sym;
boolean staticOnly = false;
@Override
ReferenceLookupHelper unboundLookup(InferenceContext inferenceContext) {
if (TreeInfo.isStaticSelector(referenceTree.expr, names)) {
if (argtypes.nonEmpty() &&
(argtypes.head.hasTag(NONE) ||
- types.isSubtypeUnchecked(inferenceContext.asUndetVar(argtypes.head), originalSite))) {
+ types.isSubtypeUnchecked(inferenceContext.asUndetVar(argtypes.head.referenceProjectionOrSelf()), originalSite))) {
return new UnboundMethodReferenceLookupHelper(referenceTree, name,
originalSite, argtypes, typeargtypes, maxPhase);
} else {
return new ReferenceLookupHelper(referenceTree, name, site, argtypes, typeargtypes, maxPhase) {
@Override
UnboundMethodReferenceLookupHelper(JCMemberReference referenceTree, Name name, Type site,
List<Type> argtypes, List<Type> typeargtypes, MethodResolutionPhase maxPhase) {
super(referenceTree, name, site, argtypes.tail, typeargtypes, maxPhase);
if (site.isRaw() && !argtypes.head.hasTag(NONE)) {
- Type asSuperSite = types.asSuper(argtypes.head, site.tsym);
+ Type asSuperSite = types.asSuper(argtypes.head.referenceProjectionOrSelf(), site.tsym);
this.site = types.skipTypeVars(asSuperSite, true);
}
}
@Override
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, site.getMetadata());
+ this.site = new ClassType(site.getEnclosingType(), site.tsym.type.getTypeArguments(), site.tsym, site.getMetadata(), site.getFlavor());
needsInference = true;
}
}
@Override
//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,
- types.asSuper(env.enclClass.type, c), env.enclClass.sym);
+ types.asSuper(env.enclClass.type.referenceProjectionOrSelf(), c), env.enclClass.sym);
}
}
//find a direct super type that is a subtype of 'c'
for (Type i : types.directSupertypes(env.enclClass.type)) {
if (i.tsym.isSubClass(c, types) && i.tsym != c) {
< prev index next >