Lines Matching refs:sym
166 env.enclClass.sym.outermostClass() ==
191 isInnerSubClass(env.enclClass.sym, c.owner);
226 * @param sym The symbol.
228 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym) {
229 return isAccessible(env, site, sym, false);
231 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym, boolean checkInner) {
232 if (sym.name == names.init && sym.owner != site.tsym) return false;
233 switch ((short)(sym.flags() & AccessFlags)) {
236 (env.enclClass.sym == sym.owner // fast special case
238 env.enclClass.sym.outermostClass() ==
239 sym.owner.outermostClass())
241 sym.isInheritedIn(site.tsym, types);
244 (env.toplevel.packge == sym.owner.owner // fast special case
246 env.toplevel.packge == sym.packge())
250 sym.isInheritedIn(site.tsym, types)
252 notOverriddenIn(site, sym);
255 (env.toplevel.packge == sym.owner.owner // fast special case
257 env.toplevel.packge == sym.packge()
259 isProtectedAccessible(sym, env.enclClass.sym, site)
263 env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)
267 notOverriddenIn(site, sym);
269 return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);
273 /* `sym' is accessible only if not overridden by
275 * (because, if it is overridden, `sym' is not strictly
279 private boolean notOverriddenIn(Type site, Symbol sym) {
280 if (sym.kind != MTH || sym.isConstructor() || sym.isStatic())
283 Symbol s2 = ((MethodSymbol)sym).implementation(site.tsym, types, true);
284 return (s2 == null || s2 == sym || sym.owner == s2.owner ||
286 !types.isSubSignature(types.memberType(site, s2), types.memberType(site, sym)));
292 * @param sym The symbol with protected access
297 boolean isProtectedAccessible(Symbol sym, ClassSymbol c, Type site) {
299 !(c.isSubClass(sym.owner, types) &&
304 ((sym.flags() & STATIC) != 0 || sym.kind == TYP || site.tsym.isSubClass(c, types))))
472 Symbol location = env.enclClass.sym;
542 Symbol sym;
545 if (e.sym.kind == VAR && (e.sym.flags_field & SYNTHETIC) == 0) {
546 return isAccessible(env, site, e.sym)
547 ? e.sym : new AccessError(env, site, e.sym);
553 sym = findField(env, site, name, st.tsym);
554 if (sym.kind < bestSoFar.kind) bestSoFar = sym;
559 sym = findField(env, site, name, l.head.tsym);
560 if (bestSoFar.kind < AMBIGUOUS && sym.kind < AMBIGUOUS &&
561 sym.owner != bestSoFar.owner)
562 bestSoFar = new AmbiguityError(bestSoFar, sym);
563 else if (sym.kind < bestSoFar.kind)
564 bestSoFar = sym;
578 Symbol sym = findField(env, site, name, site.tsym);
579 if (sym.kind == VAR) return (VarSymbol)sym;
592 Symbol sym;
599 (e.sym.kind != VAR ||
600 (e.sym.flags_field & SYNTHETIC) != 0))
602 sym = (e.scope != null)
603 ? e.sym
605 env1, env1.enclClass.sym.type, name, env1.enclClass.sym);
606 if (sym.exists()) {
608 sym.kind == VAR &&
609 sym.owner.kind == TYP &&
610 (sym.flags() & STATIC) == 0)
611 return new StaticError(sym);
613 return sym;
614 } else if (sym.kind < bestSoFar.kind) {
615 bestSoFar = sym;
618 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
622 sym = findField(env, syms.predefClass.type, name, syms.predefClass);
623 if (sym.exists())
624 return sym;
630 sym = e.sym;
632 if (sym.kind == VAR) {
633 if (e.sym.owner.type != origin)
634 sym = sym.clone(e.getOrigin().owner);
635 return isAccessible(env, origin, sym)
636 ? sym : new AccessError(env, origin, sym);
643 sym = e.sym;
644 if (sym.kind != VAR)
646 // invariant: sym.kind == VAR
647 if (bestSoFar.kind < AMBIGUOUS && sym.owner != bestSoFar.owner)
648 return new AmbiguityError(bestSoFar, sym);
651 bestSoFar = isAccessible(env, origin.type, sym)
652 ? sym : new AccessError(env, origin.type, sym);
669 * @param sym Proposed new best match.
679 Symbol sym,
684 if (sym.kind == ERR) return bestSoFar;
685 if (!sym.isInheritedIn(site.tsym, types)) return bestSoFar;
686 Assert.check(sym.kind < AMBIGUOUS);
688 rawInstantiate(env, site, sym, argtypes, typeargtypes,
693 return wrongMethod.setWrongSym(sym, ex.getDiagnostic());
696 wrongMethods.addCandidate(currentStep, wrongMethod.sym, wrongMethod.explanation);
698 return wrongMethods.addCandidate(currentStep, sym, ex.getDiagnostic());
703 if (!isAccessible(env, site, sym)) {
705 ? new AccessError(env, site, sym)
709 ? sym
710 : mostSpecific(sym, bestSoFar, env, site,
801 Symbol err1 = mostSpecific(m1, e.sym, env, site, allowBoxing, useVarargs);
804 if (err1 == e.sym && err2 == e.sym2) return m2;
807 ((AmbiguityError)err1).sym == ((AmbiguityError)err2).sym)
947 //- System.out.println(" e " + e.sym);
948 if (e.sym.kind == MTH &&
949 (e.sym.flags_field & SYNTHETIC) == 0) {
951 e.sym, bestSoFar,
993 Symbol sym;
998 sym = findMethod(
999 env1, env1.enclClass.sym.type, name, argtypes, typeargtypes,
1001 if (sym.exists()) {
1003 sym.kind == MTH &&
1004 sym.owner.kind == TYP &&
1005 (sym.flags() & STATIC) == 0) return new StaticError(sym);
1006 else return sym;
1007 } else if (sym.kind < bestSoFar.kind) {
1008 bestSoFar = sym;
1010 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
1014 sym = findMethod(env, syms.predefClass.type, name, argtypes,
1016 if (sym.exists())
1017 return sym;
1021 sym = e.sym;
1023 if (sym.kind == MTH) {
1024 if (e.sym.owner.type != origin)
1025 sym = sym.clone(e.getOrigin().owner);
1026 if (!isAccessible(env, origin, sym))
1027 sym = new AccessError(env, origin, sym);
1030 sym, bestSoFar,
1039 sym = e.sym;
1041 if (sym.kind == MTH) {
1042 if (e.sym.owner.type != origin)
1043 sym = sym.clone(e.getOrigin().owner);
1044 if (!isAccessible(env, origin, sym))
1045 sym = new AccessError(env, origin, sym);
1048 sym, bestSoFar,
1085 Symbol sym;
1088 if (e.sym.kind == TYP) {
1089 return isAccessible(env, site, e.sym)
1090 ? e.sym
1091 : new AccessError(env, site, e.sym);
1097 sym = findMemberType(env, site, name, st.tsym);
1098 if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1103 sym = findMemberType(env, site, name, l.head.tsym);
1104 if (bestSoFar.kind < AMBIGUOUS && sym.kind < AMBIGUOUS &&
1105 sym.owner != bestSoFar.owner)
1106 bestSoFar = new AmbiguityError(bestSoFar, sym);
1107 else if (sym.kind < bestSoFar.kind)
1108 bestSoFar = sym;
1121 Symbol sym = loadClass(env, e.sym.flatName());
1122 if (bestSoFar.kind == TYP && sym.kind == TYP &&
1123 bestSoFar != sym)
1124 return new AmbiguityError(bestSoFar, sym);
1125 else if (sym.kind < bestSoFar.kind)
1126 bestSoFar = sym;
1137 Symbol sym;
1144 if (e.sym.kind == TYP) {
1146 e.sym.type.tag == TYPEVAR &&
1147 e.sym.owner.kind == TYP) return new StaticError(e.sym);
1148 return e.sym;
1152 sym = findMemberType(env1, env1.enclClass.sym.type, name,
1153 env1.enclClass.sym);
1154 if (staticOnly && sym.kind == TYP &&
1155 sym.type.tag == CLASS &&
1156 sym.type.getEnclosingType().tag == CLASS &&
1157 env1.enclClass.sym.type.isParameterized() &&
1158 sym.type.getEnclosingType().isParameterized())
1159 return new StaticError(sym);
1160 else if (sym.exists()) return sym;
1161 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1164 if ((encl.sym.flags() & STATIC) != 0)
1169 sym = findGlobalType(env, env.toplevel.namedImportScope, name);
1170 if (sym.exists()) return sym;
1171 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1173 sym = findGlobalType(env, env.toplevel.packge.members(), name);
1174 if (sym.exists()) return sym;
1175 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1177 sym = findGlobalType(env, env.toplevel.starImportScope, name);
1178 if (sym.exists()) return sym;
1179 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1193 Symbol sym;
1196 sym = findVar(env, name);
1197 if (sym.exists()) return sym;
1198 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1202 sym = findType(env, name);
1203 if (sym.exists()) return sym;
1204 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1227 Symbol sym = loadClass(env, fullname);
1228 if (sym.exists()) {
1230 if (name == sym.name) return sym;
1232 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1247 Symbol sym;
1249 sym = findField(env, site, name, site.tsym);
1250 if (sym.exists()) return sym;
1251 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1255 sym = findMemberType(env, site, name, site.tsym);
1256 if (sym.exists()) return sym;
1257 else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
1268 /** If `sym' is a bad symbol: report error and return errSymbol
1274 * @param sym The symbol that was found, or a ResolveError.
1283 Symbol access(Symbol sym,
1291 if (sym.kind >= AMBIGUOUS) {
1292 ResolveError errSym = (ResolveError)sym;
1297 sym = errSym.access(name, qualified ? site.tsym : syms.noSymbol);
1299 return sym;
1304 Symbol access(Symbol sym,
1311 return access(sym, pos, site.tsym, site, name, qualified, argtypes, typeargtypes);
1316 Symbol access(Symbol sym,
1322 if (sym.kind >= AMBIGUOUS)
1323 return access(sym, pos, location, site, name, qualified, List.<Type>nil(), null);
1325 return sym;
1330 Symbol access(Symbol sym,
1335 return access(sym, pos, site.tsym, site, name, qualified);
1338 /** Check that sym is not an abstract method.
1340 void checkNonAbstract(DiagnosticPosition pos, Symbol sym) {
1341 if ((sym.flags() & ABSTRACT) != 0)
1343 kindName(sym), sym, sym.location());
1358 if ((e.sym.flags() & ABSTRACT) != 0)
1360 System.err.print(e.sym + " ");
1398 pos, env.enclClass.sym.type, name, false);
1413 Symbol sym = startResolution();
1417 sym.kind >= ERRONEOUS) {
1419 sym = findFun(env, name, argtypes, typeargtypes,
1422 methodResolutionCache.put(steps.head, sym);
1425 if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
1428 sym = access(methodResolutionCache.get(errPhase),
1429 pos, env.enclClass.sym.type, name, false, argtypes, typeargtypes);
1432 return sym;
1458 Symbol sym = startResolution();
1462 sym.kind >= ERRONEOUS) {
1464 sym = findMethod(env, site, name, argtypes, typeargtypes,
1467 methodResolutionCache.put(steps.head, sym);
1470 if (sym.kind >= AMBIGUOUS) {
1474 sym = findPolymorphicSignatureInstance(env,
1481 sym = access(methodResolutionCache.get(errPhase),
1485 } else if (allowMethodHandles && sym.isPolymorphicSignatureGeneric()) {
1488 sym = findPolymorphicSignatureInstance(env,
1489 site, name, (MethodSymbol)sym, argtypes);
1491 return sym;
1518 Symbol sym = e.sym;
1519 if (types.isSameType(mtype, sym.type) &&
1520 (sym.flags() & Flags.STATIC) == (flags & Flags.STATIC) &&
1521 types.isSameType(sym.owner.type, site)) {
1522 m = sym;
1548 Symbol sym = resolveQualifiedMethod(
1550 if (sym.kind == MTH) return (MethodSymbol)sym;
1570 Symbol sym = startResolution();
1574 sym.kind >= ERRONEOUS) {
1576 sym = resolveConstructor(pos, env, site, argtypes, typeargtypes,
1579 methodResolutionCache.put(steps.head, sym);
1582 if (sym.kind >= AMBIGUOUS) {//if nothing is found return the 'first' error
1584 sym = access(methodResolutionCache.get(errPhase),
1588 return sym;
1606 Symbol sym = startResolution();
1610 sym.kind >= ERRONEOUS) {
1612 sym = resolveConstructor(pos, env, site, argtypes, typeargtypes,
1615 methodResolutionCache.put(steps.head, sym);
1618 if (sym.kind >= AMBIGUOUS) {
1619 final JCDiagnostic details = sym.kind == WRONG_MTH ?
1620 ((InapplicableSymbolError)sym).explanation :
1634 sym = access(errSym, pos, site, names.init, true, argtypes, typeargtypes);
1637 return sym;
1656 Symbol sym = findMethod(env, site,
1660 chk.checkDeprecated(pos, env.info.scope.owner, sym);
1661 return sym;
1675 Symbol sym = resolveConstructor(
1677 if (sym.kind == MTH) return (MethodSymbol)sym;
1692 Symbol sym = findMethod(env, syms.predefClass.type, name, argtypes,
1694 if (boxingEnabled && sym.kind >= WRONG_MTHS)
1695 sym = findMethod(env, syms.predefClass.type, name, argtypes,
1697 return access(sym, pos, env.enclClass.sym.type, name,
1741 if (env1.enclClass.sym == c) {
1742 Symbol sym = env1.info.scope.lookup(name).sym;
1743 if (sym != null) {
1744 if (staticOnly) sym = new StaticError(sym);
1745 return access(sym, pos, env.enclClass.sym.type,
1749 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
1773 if (env1.enclClass.sym.isSubClass(member.owner, types)) {
1774 Symbol sym = env1.info.scope.lookup(name).sym;
1775 if (sym != null) {
1776 if (staticOnly) sym = new StaticError(sym);
1777 return access(sym, pos, env.enclClass.sym.type,
1781 if ((env1.enclClass.sym.flags() & STATIC) != 0)
1802 if (env.info.isSelfCall && thisType.tsym == env.enclClass.sym)
1814 logResolveError(error, tree.pos(), env.enclClass.sym, env.enclClass.type, null, null, null);
1920 Symbol sym;
1922 InvalidSymbolError(int kind, Symbol sym, String debugName) {
1924 this.sym = sym;
1934 return super.toString() + " wrongSym=" + sym;
1939 if (sym.kind >= AMBIGUOUS)
1940 return ((ResolveError)sym).access(name, location);
1941 else if ((sym.kind & ERRONEOUS) == 0 && (sym.kind & TYP) != 0)
1942 return types.createErrorType(name, location, sym.type).tsym;
1944 return sym;
2048 InapplicableSymbolError(Symbol sym) {
2049 super(WRONG_MTH, sym, "inapplicable symbol error");
2052 /** Update sym and explanation and return this.
2054 InapplicableSymbolError setWrongSym(Symbol sym, JCDiagnostic explanation) {
2055 this.sym = sym;
2056 if (this.sym == sym && explanation != null)
2061 /** Update sym and return this.
2063 InapplicableSymbolError setWrongSym(Symbol sym) {
2064 this.sym = sym;
2095 Symbol ws = sym.asMemberOf(site, types);
2127 InapplicableSymbolsError(Symbol sym) {
2163 Symbol addCandidate(MethodResolutionPhase currentStep, Symbol sym, JCDiagnostic details) {
2164 Candidate c = new Candidate(currentStep, sym, details);
2176 Symbol sym = candidates.iterator().next().sym;
2177 return sym.name == names.init ?
2178 sym.owner.name :
2179 sym.name;
2185 final Symbol sym;
2188 private Candidate(MethodResolutionPhase step, Symbol sym, JCDiagnostic details) {
2190 this.sym = sym;
2196 Kinds.kindName(sym),
2197 sym.location(site, types),
2198 sym.asMemberOf(site, types),
2205 Symbol s1 = this.sym;
2206 Symbol s2 = ((Candidate)o).sym;
2217 return (((sym.flags() & VARARGS) != 0 && step == VARARITY) ||
2218 (sym.flags() & VARARGS) == 0 && step == (boxingEnabled ? BOX : BASIC));
2232 AccessError(Symbol sym) {
2233 this(null, null, sym);
2236 AccessError(Env<AttrContext> env, Type site, Symbol sym) {
2237 super(HIDDEN, sym, "access error");
2241 log.error("proc.messager", sym + " @ " + site + " is inaccessible.");
2257 if (sym.owner.type.tag == ERROR)
2260 if (sym.name == names.init && sym.owner != site.tsym) {
2264 else if ((sym.flags() & PUBLIC) != 0
2269 sym, sym.location());
2271 else if ((sym.flags() & (PRIVATE | PROTECTED)) != 0) {
2273 pos, "report.access", sym,
2274 asFlagSet(sym.flags() & (PRIVATE | PROTECTED)),
2275 sym.location());
2279 pos, "not.def.public.cant.access", sym, sym.location());
2290 StaticError(Symbol sym) {
2291 super(STATICERR, sym, "static error");
2302 Symbol errSym = ((sym.kind == TYP && sym.type.tag == CLASS)
2303 ? types.erasure(sym.type).tsym
2304 : sym);
2306 "non-static.cant.be.ref", kindName(sym), errSym);
2335 if (pair.sym.kind == AMBIGUOUS)
2336 pair = (AmbiguityError)pair.sym;
2341 Name sname = pair.sym.name;
2342 if (sname == names.init) sname = pair.sym.owner.name;
2345 kindName(pair.sym),
2346 pair.sym,
2347 pair.sym.location(site, types),
2390 Symbol sym = methodNotFound;
2394 sym.kind >= WRONG_MTHS) {
2395 sym = methodResolutionCache.get(steps.head);