404 * as a member.
405 * @param sym The symbol.
406 */
407 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym) {
408 return isAccessible(env, site, sym, false);
409 }
410 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym, boolean checkInner) {
411 if (sym.name == names.init && sym.owner != site.tsym) return false;
412
413 /* 15.9.5.1: Note that it is possible for the signature of the anonymous constructor
414 to refer to an inaccessible type
415 */
416 if (env.enclMethod != null && (env.enclMethod.mods.flags & ANONCONSTR) != 0)
417 return true;
418
419 if (env.info.visitingServiceImplementation &&
420 env.toplevel.modle == sym.packge().modle) {
421 return true;
422 }
423
424 switch ((short)(sym.flags() & AccessFlags)) {
425 case PRIVATE:
426 return
427 (env.enclClass.sym == sym.owner // fast special case
428 ||
429 env.enclClass.sym.outermostClass() ==
430 sym.owner.outermostClass()
431 ||
432 privateMemberInPermitsClauseIfAllowed(env, sym))
433 &&
434 sym.isInheritedIn(site.tsym, types);
435 case 0:
436 return
437 (env.toplevel.packge == sym.owner.owner // fast special case
438 ||
439 env.toplevel.packge == sym.packge())
440 &&
441 isAccessible(env, site, checkInner)
442 &&
443 sym.isInheritedIn(site.tsym, types)
444 &&
445 notOverriddenIn(site, sym);
446 case PROTECTED:
447 return
448 (env.toplevel.packge == sym.owner.owner // fast special case
449 ||
450 env.toplevel.packge == sym.packge()
451 ||
452 isProtectedAccessible(sym, env.enclClass.sym, site)
453 ||
454 // OK to select instance method or field from 'super' or type name
455 // (but type names should be disallowed elsewhere!)
456 env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)
457 &&
458 isAccessible(env, site, checkInner)
459 &&
460 notOverriddenIn(site, sym);
461 default: // this case includes erroneous combinations as well
462 return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);
463 }
464 }
465
466 private boolean privateMemberInPermitsClauseIfAllowed(Env<AttrContext> env, Symbol sym) {
467 return allowPrivateMembersInPermitsClause &&
468 env.info.isPermitsClause &&
469 ((JCClassDecl) env.tree).sym.outermostClass() == sym.owner.outermostClass();
470 }
471
472 //where
473 /* `sym' is accessible only if not overridden by
474 * another symbol which is a member of `site'
475 * (because, if it is overridden, `sym' is not strictly
476 * speaking a member of `site'). A polymorphic signature method
477 * cannot be overridden (e.g. MH.invokeExact(Object[])).
478 */
479 private boolean notOverriddenIn(Type site, Symbol sym) {
480 if (sym.kind != MTH || sym.isConstructor() || sym.isStatic())
481 return true;
482 else {
1513 Symbol sym = null;
1514 for (Symbol s : env1.info.scope.getSymbolsByName(name)) {
1515 if (s.kind == VAR && (s.flags_field & SYNTHETIC) == 0) {
1516 sym = s;
1517 if (staticOnly) {
1518 return new StaticError(sym);
1519 }
1520 break;
1521 }
1522 }
1523 if (isStatic(env1)) staticOnly = true;
1524 if (sym == null) {
1525 sym = findField(env1, env1.enclClass.sym.type, name, env1.enclClass.sym);
1526 }
1527 if (sym.exists()) {
1528 if (sym.kind == VAR &&
1529 sym.owner.kind == TYP &&
1530 (sym.flags() & STATIC) == 0) {
1531 if (staticOnly)
1532 return new StaticError(sym);
1533 if (env1.info.ctorPrologue && !isAllowedEarlyReference(pos, env1, (VarSymbol)sym))
1534 return new RefBeforeCtorCalledError(sym);
1535 }
1536 return sym;
1537 } else {
1538 bestSoFar = bestOf(bestSoFar, sym);
1539 }
1540
1541 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
1542 env1 = env1.outer;
1543 }
1544
1545 Symbol sym = findField(env, syms.predefClass.type, name, syms.predefClass);
1546 if (sym.exists())
1547 return sym;
1548 if (bestSoFar.exists())
1549 return bestSoFar;
1550
1551 Symbol origin = null;
1552 for (Scope sc : new Scope[] { env.toplevel.namedImportScope, env.toplevel.starImportScope }) {
1553 for (Symbol currentSymbol : sc.getSymbolsByName(name)) {
1554 if (currentSymbol.kind != VAR)
4297 List<Type> argtypes,
4298 List<Type> typeargtypes) {
4299 if (name == names.error)
4300 return null;
4301
4302 Pair<Symbol, JCDiagnostic> c = errCandidate();
4303 Symbol ws = c.fst.asMemberOf(site, types);
4304 UnaryOperator<JCDiagnostic> rewriter = compactMethodDiags ?
4305 d -> MethodResolutionDiagHelper.rewrite(diags, pos, log.currentSource(), dkind, c.snd) : null;
4306
4307 // If the problem is due to type arguments, then the method parameters aren't relevant,
4308 // so use the error message that omits them to avoid confusion.
4309 switch (c.snd.getCode()) {
4310 case "compiler.misc.wrong.number.type.args":
4311 case "compiler.misc.explicit.param.do.not.conform.to.bounds":
4312 return diags.create(dkind, log.currentSource(), pos,
4313 "cant.apply.symbol.noargs",
4314 rewriter,
4315 kindName(ws),
4316 ws.name == names.init ? ws.owner.name : ws.name,
4317 kindName(ws.owner),
4318 ws.owner.type,
4319 c.snd);
4320 default:
4321 // Avoid saying "constructor Array in class Array"
4322 if (ws.owner == syms.arrayClass && ws.name == names.init) {
4323 return diags.create(dkind, log.currentSource(), pos,
4324 "cant.apply.array.ctor",
4325 rewriter,
4326 methodArguments(ws.type.getParameterTypes()),
4327 methodArguments(argtypes),
4328 c.snd);
4329 }
4330 return diags.create(dkind, log.currentSource(), pos,
4331 "cant.apply.symbol",
4332 rewriter,
4333 kindName(ws),
4334 ws.name == names.init ? ws.owner.name : ws.name,
4335 methodArguments(ws.type.getParameterTypes()),
4336 methodArguments(argtypes),
4337 kindName(ws.owner),
5198 final MethodResolutionPhase step;
5199 final Symbol sym;
5200 final JCDiagnostic details;
5201 final Type mtype;
5202
5203 private Candidate(MethodResolutionPhase step, Symbol sym, JCDiagnostic details, Type mtype) {
5204 this.step = step;
5205 this.sym = sym;
5206 this.details = details;
5207 this.mtype = mtype;
5208 }
5209
5210 boolean isApplicable() {
5211 return mtype != null;
5212 }
5213 }
5214
5215 DeferredAttr.AttrMode attrMode() {
5216 return attrMode;
5217 }
5218
5219 boolean internal() {
5220 return internalResolution;
5221 }
5222 }
5223
5224 MethodResolutionContext currentResolutionContext = null;
5225 }
|
404 * as a member.
405 * @param sym The symbol.
406 */
407 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym) {
408 return isAccessible(env, site, sym, false);
409 }
410 public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym, boolean checkInner) {
411 if (sym.name == names.init && sym.owner != site.tsym) return false;
412
413 /* 15.9.5.1: Note that it is possible for the signature of the anonymous constructor
414 to refer to an inaccessible type
415 */
416 if (env.enclMethod != null && (env.enclMethod.mods.flags & ANONCONSTR) != 0)
417 return true;
418
419 if (env.info.visitingServiceImplementation &&
420 env.toplevel.modle == sym.packge().modle) {
421 return true;
422 }
423
424 ClassSymbol enclosingCsym = env.enclClass.sym;
425 try {
426 switch ((short)(sym.flags() & AccessFlags)) {
427 case PRIVATE:
428 return
429 (env.enclClass.sym == sym.owner // fast special case
430 ||
431 env.enclClass.sym.outermostClass() ==
432 sym.owner.outermostClass()
433 ||
434 privateMemberInPermitsClauseIfAllowed(env, sym))
435 &&
436 sym.isInheritedIn(site.tsym, types);
437 case 0:
438 return
439 (env.toplevel.packge == sym.owner.owner // fast special case
440 ||
441 env.toplevel.packge == sym.packge())
442 &&
443 isAccessible(env, site, checkInner)
444 &&
445 sym.isInheritedIn(site.tsym, types)
446 &&
447 notOverriddenIn(site, sym);
448 case PROTECTED:
449 return
450 (env.toplevel.packge == sym.owner.owner // fast special case
451 ||
452 env.toplevel.packge == sym.packge()
453 ||
454 isProtectedAccessible(sym, env.enclClass.sym, site)
455 ||
456 // OK to select instance method or field from 'super' or type name
457 // (but type names should be disallowed elsewhere!)
458 env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)
459 &&
460 isAccessible(env, site, checkInner)
461 &&
462 notOverriddenIn(site, sym);
463 default: // this case includes erroneous combinations as well
464 return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);
465 }
466 } finally {
467 env.enclClass.sym = enclosingCsym;
468 }
469 }
470
471 private boolean privateMemberInPermitsClauseIfAllowed(Env<AttrContext> env, Symbol sym) {
472 return allowPrivateMembersInPermitsClause &&
473 env.info.isPermitsClause &&
474 ((JCClassDecl) env.tree).sym.outermostClass() == sym.owner.outermostClass();
475 }
476
477 //where
478 /* `sym' is accessible only if not overridden by
479 * another symbol which is a member of `site'
480 * (because, if it is overridden, `sym' is not strictly
481 * speaking a member of `site'). A polymorphic signature method
482 * cannot be overridden (e.g. MH.invokeExact(Object[])).
483 */
484 private boolean notOverriddenIn(Type site, Symbol sym) {
485 if (sym.kind != MTH || sym.isConstructor() || sym.isStatic())
486 return true;
487 else {
1518 Symbol sym = null;
1519 for (Symbol s : env1.info.scope.getSymbolsByName(name)) {
1520 if (s.kind == VAR && (s.flags_field & SYNTHETIC) == 0) {
1521 sym = s;
1522 if (staticOnly) {
1523 return new StaticError(sym);
1524 }
1525 break;
1526 }
1527 }
1528 if (isStatic(env1)) staticOnly = true;
1529 if (sym == null) {
1530 sym = findField(env1, env1.enclClass.sym.type, name, env1.enclClass.sym);
1531 }
1532 if (sym.exists()) {
1533 if (sym.kind == VAR &&
1534 sym.owner.kind == TYP &&
1535 (sym.flags() & STATIC) == 0) {
1536 if (staticOnly)
1537 return new StaticError(sym);
1538 if (env1.info.ctorPrologue && !isAllowedEarlyReference(pos, env1, (VarSymbol)sym)) {
1539 if (!env.tree.hasTag(ASSIGN) || !TreeInfo.isIdentOrThisDotIdent(((JCAssign)env.tree).lhs)) {
1540 return new RefBeforeCtorCalledError(sym);
1541 }
1542 }
1543 }
1544 return sym;
1545 } else {
1546 bestSoFar = bestOf(bestSoFar, sym);
1547 }
1548
1549 if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
1550 env1 = env1.outer;
1551 }
1552
1553 Symbol sym = findField(env, syms.predefClass.type, name, syms.predefClass);
1554 if (sym.exists())
1555 return sym;
1556 if (bestSoFar.exists())
1557 return bestSoFar;
1558
1559 Symbol origin = null;
1560 for (Scope sc : new Scope[] { env.toplevel.namedImportScope, env.toplevel.starImportScope }) {
1561 for (Symbol currentSymbol : sc.getSymbolsByName(name)) {
1562 if (currentSymbol.kind != VAR)
4305 List<Type> argtypes,
4306 List<Type> typeargtypes) {
4307 if (name == names.error)
4308 return null;
4309
4310 Pair<Symbol, JCDiagnostic> c = errCandidate();
4311 Symbol ws = c.fst.asMemberOf(site, types);
4312 UnaryOperator<JCDiagnostic> rewriter = compactMethodDiags ?
4313 d -> MethodResolutionDiagHelper.rewrite(diags, pos, log.currentSource(), dkind, c.snd) : null;
4314
4315 // If the problem is due to type arguments, then the method parameters aren't relevant,
4316 // so use the error message that omits them to avoid confusion.
4317 switch (c.snd.getCode()) {
4318 case "compiler.misc.wrong.number.type.args":
4319 case "compiler.misc.explicit.param.do.not.conform.to.bounds":
4320 return diags.create(dkind, log.currentSource(), pos,
4321 "cant.apply.symbol.noargs",
4322 rewriter,
4323 kindName(ws),
4324 ws.name == names.init ? ws.owner.name : ws.name,
4325 ws.owner.type,
4326 c.snd);
4327 default:
4328 // Avoid saying "constructor Array in class Array"
4329 if (ws.owner == syms.arrayClass && ws.name == names.init) {
4330 return diags.create(dkind, log.currentSource(), pos,
4331 "cant.apply.array.ctor",
4332 rewriter,
4333 methodArguments(ws.type.getParameterTypes()),
4334 methodArguments(argtypes),
4335 c.snd);
4336 }
4337 return diags.create(dkind, log.currentSource(), pos,
4338 "cant.apply.symbol",
4339 rewriter,
4340 kindName(ws),
4341 ws.name == names.init ? ws.owner.name : ws.name,
4342 methodArguments(ws.type.getParameterTypes()),
4343 methodArguments(argtypes),
4344 kindName(ws.owner),
5205 final MethodResolutionPhase step;
5206 final Symbol sym;
5207 final JCDiagnostic details;
5208 final Type mtype;
5209
5210 private Candidate(MethodResolutionPhase step, Symbol sym, JCDiagnostic details, Type mtype) {
5211 this.step = step;
5212 this.sym = sym;
5213 this.details = details;
5214 this.mtype = mtype;
5215 }
5216
5217 boolean isApplicable() {
5218 return mtype != null;
5219 }
5220 }
5221
5222 DeferredAttr.AttrMode attrMode() {
5223 return attrMode;
5224 }
5225 }
5226
5227 MethodResolutionContext currentResolutionContext = null;
5228 }
|