jdk-sandbox: comparison src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java

equal deleted inserted replaced

-:6dcbdc9f99fc
+:702043a4cdeb
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Attribute.Compound;
 import com.sun.tools.javac.code.Directive.ExportsDirective;
 import com.sun.tools.javac.code.Directive.RequiresDirective;
+import com.sun.tools.javac.code.Source.Feature;
 import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 Options options = Options.instance(context);
 lint = Lint.instance(context);
 fileManager = context.get(JavaFileManager.class);
 source = Source.instance(context);
-allowSimplifiedVarargs = source.allowSimplifiedVarargs();
-allowDefaultMethods = source.allowDefaultMethods();
-allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();
-allowPrivateSafeVarargs = source.allowPrivateSafeVarargs();
-allowDiamondWithAnonymousClassCreation = source.allowDiamondWithAnonymousClassCreation();
 warnOnAnyAccessToMembers = options.isSet("warnOnAccessToMembers");
 Target target = Target.instance(context);
 syntheticNameChar = target.syntheticNameChar();
 enforceMandatoryWarnings, "sunapi", null);
 deferredLintHandler = DeferredLintHandler.instance(context);
 }
-/** Switch: simplified varargs enabled?
-*/
-boolean allowSimplifiedVarargs;
-/** Switch: default methods enabled?
-*/
-boolean allowDefaultMethods;
-/** Switch: should unrelated return types trigger a method clash?
-*/
-boolean allowStrictMethodClashCheck;
-/** Switch: can the @SafeVarargs annotation be applied to private methods?
-*/
-boolean allowPrivateSafeVarargs;
-/** Switch: can diamond inference be used in anonymous instance creation ?
-*/
-boolean allowDiamondWithAnonymousClassCreation;
 /** Character for synthetic names
 */
 char syntheticNameChar;
 /** A table mapping flat names of all compiled classes for each module in this run
 /** Warn about unsafe vararg method decl.
 *  @param pos        Position to be used for error reporting.
 */
 void warnUnsafeVararg(DiagnosticPosition pos, String key, Object... args) {
-if (lint.isEnabled(LintCategory.VARARGS) && allowSimplifiedVarargs)
+if (lint.isEnabled(LintCategory.VARARGS) && Feature.SIMPLIFIED_VARARGS.allowedInSource(source))
 log.warning(LintCategory.VARARGS, pos, key, args);
 }
 public void warnStatic(DiagnosticPosition pos, String msg, Object... args) {
 if (lint.isEnabled(LintCategory.STATIC))
 Type checkDiamond(JCNewClass tree, Type t) {
 if (!TreeInfo.isDiamond(tree) ||
 t.isErroneous()) {
 return checkClassType(tree.clazz.pos(), t, true);
 } else {
-if (tree.def != null && !allowDiamondWithAnonymousClassCreation) {
+if (tree.def != null && !Feature.DIAMOND_WITH_ANONYMOUS_CLASS_CREATION.allowedInSource(source)) {
 log.error(DiagnosticFlag.SOURCE_LEVEL, tree.clazz.pos(),
-Errors.CantApplyDiamond1(t, Fragments.DiamondAndAnonClassNotSupportedInSource(source.name)));
+Errors.CantApplyDiamond1(t, Feature.DIAMOND_WITH_ANONYMOUS_CLASS_CREATION.fragment(source.name)));
 }
 if (t.tsym.type.getTypeArguments().isEmpty()) {
 log.error(tree.clazz.pos(),
 Errors.CantApplyDiamond1(t,
 Fragments.DiamondNonGeneric(t)));
 }
 };
 void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
 MethodSymbol m = tree.sym;
-if (!allowSimplifiedVarargs) return;
+if (!Feature.SIMPLIFIED_VARARGS.allowedInSource(source)) return;
 boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;
 Type varargElemType = null;
 if (m.isVarArgs()) {
 varargElemType = types.elemtype(tree.params.last().type);
 }
 if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
 if (varargElemType != null) {
-JCDiagnostic msg = allowPrivateSafeVarargs ?
+JCDiagnostic msg = Feature.PRIVATE_SAFE_VARARGS.allowedInSource(source) ?
 diags.fragment(Fragments.VarargsTrustmeOnVirtualVarargs(m)) :
 diags.fragment(Fragments.VarargsTrustmeOnVirtualVarargsFinalOnly(m));
 log.error(tree,
 Errors.VarargsInvalidTrustmeAnno(syms.trustMeType.tsym,
 msg));
 //where
 private boolean isTrustMeAllowedOnMethod(Symbol s) {
 return (s.flags() & VARARGS) != 0 &&
 (s.isConstructor() ||
 (s.flags() & (STATIC | FINAL |
-(allowPrivateSafeVarargs ? PRIVATE : 0) )) != 0);
+(Feature.PRIVATE_SAFE_VARARGS.allowedInSource(source) ? PRIVATE : 0) )) != 0);
 }
 Type checkLocalVarType(DiagnosticPosition pos, Type t, Name name) {
 //check that resulting type is not the null type
 if (t.hasTag(BOT)) {
 }
 }
 if (useVarargs) {
 Type argtype = owntype.getParameterTypes().last();
 if (!types.isReifiable(argtype) &&
-(!allowSimplifiedVarargs ||
+(!Feature.SIMPLIFIED_VARARGS.allowedInSource(source) ||
 sym.baseSymbol().attribute(syms.trustMeType.tsym) == null ||
 !isTrustMeAllowedOnMethod(sym))) {
 warnUnchecked(env.tree.pos(),
 "unchecked.generic.array.creation",
 argtype);
 //...check each method m2 that is a member of 'site'
 for (Symbol m2 : types.membersClosure(site, false).getSymbolsByName(sym.name, cf)) {
 if (m2 == m1) continue;
 //if (i) the signature of 'sym' is not a subsignature of m1 (seen as
 //a member of 'site') and (ii) m1 has the same erasure as m2, issue an error
-if (!types.isSubSignature(sym.type, types.memberType(site, m2), allowStrictMethodClashCheck) &&
+if (!types.isSubSignature(sym.type, types.memberType(site, m2), Feature.STRICT_METHOD_CLASH_CHECK.allowedInSource(source)) &&
 types.hasSameArgs(m2.erasure(types), m1.erasure(types))) {
 sym.flags_field |= CLASH;
 if (m1 == sym) {
 log.error(pos, Errors.NameClashSameErasureNoOverride(
 m1.name, types.memberType(site, m1).asMethodType().getParameterTypes(), m1.location(),
 ClashFilter cf = new ClashFilter(site);
 //for each method m1 that is a member of 'site'...
 for (Symbol s : types.membersClosure(site, true).getSymbolsByName(sym.name, cf)) {
 //if (i) the signature of 'sym' is not a subsignature of m1 (seen as
 //a member of 'site') and (ii) 'sym' has the same erasure as m1, issue an error
-if (!types.isSubSignature(sym.type, types.memberType(site, s), allowStrictMethodClashCheck)) {
+if (!types.isSubSignature(sym.type, types.memberType(site, s), Feature.STRICT_METHOD_CLASH_CHECK.allowedInSource(source))) {
 if (types.hasSameArgs(s.erasure(types), sym.erasure(types))) {
 log.error(pos,
 Errors.NameClashSameErasureNoHide(sym, sym.location(), s, s.location()));
 return;
 } else {
 * lambda would be ambiguous).
 */
 void checkPotentiallyAmbiguousOverloads(DiagnosticPosition pos, Type site,
 MethodSymbol msym1, MethodSymbol msym2) {
 if (msym1 != msym2 &&
-allowDefaultMethods &&
+Feature.DEFAULT_METHODS.allowedInSource(source) &&
 lint.isEnabled(LintCategory.OVERLOADS) &&
 (msym1.flags() & POTENTIALLY_AMBIGUOUS) == 0 &&
 (msym2.flags() & POTENTIALLY_AMBIGUOUS) == 0) {
 Type mt1 = types.memberType(site, msym1);
 Type mt2 = types.memberType(site, msym2);

changeset 48054	702043a4cdeb
parent 47959	5dd899009525
child 48352	9b700a5c4381