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

equal deleted inserted replaced

-:d23ae2d67a5d
+:ea7475564d07
 import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.JCDiagnostic.Fragment;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.code.Lint;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Scope.WriteableScope;
 /** Warn about division by integer constant zero.
 *  @param pos        Position to be used for error reporting.
 */
 void warnDivZero(DiagnosticPosition pos) {
 if (lint.isEnabled(LintCategory.DIVZERO))
-log.warning(LintCategory.DIVZERO, pos, "div.zero");
+log.warning(LintCategory.DIVZERO, pos, Warnings.DivZero);
 }
 /**
 * Report any deferred diagnostics.
 */
 /** Report a failure to complete a class.
 *  @param pos        Position to be used for error reporting.
 *  @param ex         The failure to report.
 */
 public Type completionError(DiagnosticPosition pos, CompletionFailure ex) {
-log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, pos, "cant.access", ex.sym, ex.getDetailValue());
+log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, pos, Errors.CantAccess(ex.sym, ex.getDetailValue()));
 if (ex instanceof ClassFinder.BadClassFile) throw new Abort();
 else return syms.errType;
 }
 /** Report an error that wrong type tag was found.
 *  @param pos        Position to be used for error reporting.
 *  @param required   An internationalized string describing the type tag
 *                    required.
 *  @param found      The type that was found.
 */
-Type typeTagError(DiagnosticPosition pos, Object required, Object found) {
+Type typeTagError(DiagnosticPosition pos, JCDiagnostic required, Object found) {
 // this error used to be raised by the parser,
 // but has been delayed to this point:
 if (found instanceof Type && ((Type)found).hasTag(VOID)) {
-log.error(pos, "illegal.start.of.type");
+log.error(pos, Errors.IllegalStartOfType);
 return syms.errType;
 }
-log.error(pos, "type.found.req", found, required);
+log.error(pos, Errors.TypeFoundReq(found, required));
 return types.createErrorType(found instanceof Type ? (Type)found : syms.errType);
 }
 /** Report an error that symbol cannot be referenced before super
 *  has been called.
 *  @param pos        Position to be used for error reporting.
 *  @param sym        The referenced symbol.
 */
 void earlyRefError(DiagnosticPosition pos, Symbol sym) {
-log.error(pos, "cant.ref.before.ctor.called", sym);
+log.error(pos, Errors.CantRefBeforeCtorCalled(sym));
 }
 /** Report duplicate declaration error.
 */
 void duplicateError(DiagnosticPosition pos, Symbol sym) {
 if (!sym.type.isErroneous()) {
 Symbol location = sym.location();
 if (location.kind == MTH &&
 ((MethodSymbol)location).isStaticOrInstanceInit()) {
-log.error(pos, "already.defined.in.clinit", kindName(sym), sym,
+log.error(pos,
-kindName(sym.location()), kindName(sym.location().enclClass()),
+Errors.AlreadyDefinedInClinit(kindName(sym),
-sym.location().enclClass());
+sym,
+kindName(sym.location()),
+kindName(sym.location().enclClass()),
+sym.location().enclClass()));
 } else {
-log.error(pos, "already.defined", kindName(sym), sym,
+log.error(pos,
-kindName(sym.location()), sym.location());
+Errors.AlreadyDefined(kindName(sym),
+sym,
+kindName(sym.location()),
+sym.location()));
 }
 }
 }
 /** Report array/varargs duplicate declaration
 */
 void varargsDuplicateError(DiagnosticPosition pos, Symbol sym1, Symbol sym2) {
 if (!sym1.type.isErroneous() && !sym2.type.isErroneous()) {
-log.error(pos, "array.and.varargs", sym1, sym2, sym2.location());
+log.error(pos, Errors.ArrayAndVarargs(sym1, sym2, sym2.location()));
 }
 }
 /* ************************************************************************
 * duplicate declaration checking
 /**
 * Check context to be used when evaluating assignment/return statements
 */
 CheckContext basicHandler = new CheckContext() {
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
-log.error(pos, "prob.found.req", details);
+log.error(pos, Errors.ProbFoundReq(details));
 }
 public boolean compatible(Type found, Type req, Warner warn) {
 return types.isAssignable(found, req, warn);
 }
 return found;
 if (checkContext.compatible(found, req, checkContext.checkWarner(pos, found, req))) {
 return found;
 } else {
 if (found.isNumeric() && req.isNumeric()) {
-checkContext.report(pos, diags.fragment("possible.loss.of.precision", found, req));
+checkContext.report(pos, diags.fragment(Fragments.PossibleLossOfPrecision(found, req)));
 return types.createErrorType(found);
 }
-checkContext.report(pos, diags.fragment("inconvertible.types", found, req));
+checkContext.report(pos, diags.fragment(Fragments.InconvertibleTypes(found, req)));
 return types.createErrorType(found);
 }
 }
 /** Check that a given type can be cast to a given target type.
 }
 Type checkCastable(DiagnosticPosition pos, Type found, Type req, CheckContext checkContext) {
 if (types.isCastable(found, req, castWarner(pos, found, req))) {
 return req;
 } else {
-checkContext.report(pos, diags.fragment("inconvertible.types", found, req));
+checkContext.report(pos, diags.fragment(Fragments.InconvertibleTypes(found, req)));
 return types.createErrorType(found);
 }
 }
 /** Check for redundant casts (i.e. where source type is a subtype of target type)
 && !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))
 && !is292targetTypeCast(tree)) {
 deferredLintHandler.report(() -> {
 if (lint.isEnabled(LintCategory.CAST))
 log.warning(LintCategory.CAST,
-tree.pos(), "redundant.cast", tree.clazz.type);
+tree.pos(), Warnings.RedundantCast(tree.clazz.type));
 });
 }
 }
 //where
 private boolean is292targetTypeCast(JCTypeCast tree) {
 *  @param pos           Position to be used for error reporting.
 *  @param t             The type to be checked.
 */
 Type checkNonVoid(DiagnosticPosition pos, Type t) {
 if (t.hasTag(VOID)) {
-log.error(pos, "void.not.allowed.here");
+log.error(pos, Errors.VoidNotAllowedHere);
 return types.createErrorType(t);
 } else {
 return t;
 }
 }
 Type checkClassOrArrayType(DiagnosticPosition pos, Type t) {
 if (!t.hasTag(CLASS) && !t.hasTag(ARRAY) && !t.hasTag(ERROR)) {
 return typeTagError(pos,
-diags.fragment("type.req.class.array"),
+diags.fragment(Fragments.TypeReqClassArray),
 asTypeParam(t));
 } else {
 return t;
 }
 }
 *  @param t             The type to be checked.
 */
 Type checkClassType(DiagnosticPosition pos, Type t) {
 if (!t.hasTag(CLASS) && !t.hasTag(ERROR)) {
 return typeTagError(pos,
-diags.fragment("type.req.class"),
+diags.fragment(Fragments.TypeReqClass),
 asTypeParam(t));
 } else {
 return t;
 }
 }
 //where
 private Object asTypeParam(Type t) {
 return (t.hasTag(TYPEVAR))
-? diags.fragment("type.parameter", t)
+? diags.fragment(Fragments.TypeParameter(t))
 : t;
 }
 /** Check that type is a valid qualifier for a constructor reference expression
 */
 Type checkConstructorRefType(DiagnosticPosition pos, Type t) {
 t = checkClassOrArrayType(pos, t);
 if (t.hasTag(CLASS)) {
 if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
-log.error(pos, "abstract.cant.be.instantiated", t.tsym);
+log.error(pos, Errors.AbstractCantBeInstantiated(t.tsym));
 t = types.createErrorType(t);
 } else if ((t.tsym.flags() & ENUM) != 0) {
-log.error(pos, "enum.cant.be.instantiated");
+log.error(pos, Errors.EnumCantBeInstantiated);
 t = types.createErrorType(t);
 } else {
 t = checkClassType(pos, t, true);
 }
 } else if (t.hasTag(ARRAY)) {
 if (!types.isReifiable(((ArrayType)t).elemtype)) {
-log.error(pos, "generic.array.creation");
+log.error(pos, Errors.GenericArrayCreation);
 t = types.createErrorType(t);
 }
 }
 return t;
 }
 if (noBounds && t.isParameterized()) {
 List<Type> args = t.getTypeArguments();
 while (args.nonEmpty()) {
 if (args.head.hasTag(WILDCARD))
 return typeTagError(pos,
-diags.fragment("type.req.exact"),
+diags.fragment(Fragments.TypeReqExact),
 args.head);
 args = args.tail;
 }
 }
 return t;
 Type checkRefType(DiagnosticPosition pos, Type t) {
 if (t.isReference())
 return t;
 else
 return typeTagError(pos,
-diags.fragment("type.req.ref"),
+diags.fragment(Fragments.TypeReqRef),
 t);
 }
 /** Check that each type is a reference type, i.e. a class, interface or array type
 *  or a type variable.
 Type checkNullOrRefType(DiagnosticPosition pos, Type t) {
 if (t.isReference() || t.hasTag(BOT))
 return t;
 else
 return typeTagError(pos,
-diags.fragment("type.req.ref"),
+diags.fragment(Fragments.TypeReqRef),
 t);
 }
 /** Check that flag set does not contain elements of two conflicting sets. s
 *  Return true if it doesn't.
 *  @param set2          Conflicting flags set #2.
 */
 boolean checkDisjoint(DiagnosticPosition pos, long flags, long set1, long set2) {
 if ((flags & set1) != 0 && (flags & set2) != 0) {
 log.error(pos,
-"illegal.combination.of.modifiers",
+Errors.IllegalCombinationOfModifiers(asFlagSet(TreeInfo.firstFlag(flags & set1)),
-asFlagSet(TreeInfo.firstFlag(flags & set1)),
+asFlagSet(TreeInfo.firstFlag(flags & set2))));
-asFlagSet(TreeInfo.firstFlag(flags & set2)));
 return false;
 } else
 return true;
 }
 log.error(DiagnosticFlag.SOURCE_LEVEL, tree.clazz.pos(),
 Errors.CantApplyDiamond1(t, Fragments.DiamondAndAnonClassNotSupportedInSource(source.name)));
 }
 if (t.tsym.type.getTypeArguments().isEmpty()) {
 log.error(tree.clazz.pos(),
-"cant.apply.diamond.1",
+Errors.CantApplyDiamond1(t,
-t, diags.fragment("diamond.non.generic", t));
+Fragments.DiamondNonGeneric(t)));
 return types.createErrorType(t);
 } else if (tree.typeargs != null &&
 tree.typeargs.nonEmpty()) {
 log.error(tree.clazz.pos(),
-"cant.apply.diamond.1",
+Errors.CantApplyDiamond1(t,
-t, diags.fragment("diamond.and.explicit.params", t));
+Fragments.DiamondAndExplicitParams(t)));
 return types.createErrorType(t);
 } else {
 return t;
 }
 }
 if (m.isVarArgs()) {
 varargElemType = types.elemtype(tree.params.last().type);
 }
 if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
 if (varargElemType != null) {
+JCDiagnostic msg = allowPrivateSafeVarargs ?
+diags.fragment(Fragments.VarargsTrustmeOnVirtualVarargs(m)) :
+diags.fragment(Fragments.VarargsTrustmeOnVirtualVarargsFinalOnly(m));
 log.error(tree,
-"varargs.invalid.trustme.anno",
+Errors.VarargsInvalidTrustmeAnno(syms.trustMeType.tsym,
-syms.trustMeType.tsym,
+msg));
-allowPrivateSafeVarargs ?
-diags.fragment("varargs.trustme.on.virtual.varargs", m) :
-diags.fragment("varargs.trustme.on.virtual.varargs.final.only", m));
 } else {
 log.error(tree,
-"varargs.invalid.trustme.anno",
+Errors.VarargsInvalidTrustmeAnno(syms.trustMeType.tsym,
-syms.trustMeType.tsym,
+Fragments.VarargsTrustmeOnNonVarargsMeth(m)));
-diags.fragment("varargs.trustme.on.non.varargs.meth", m));
 }
 } else if (hasTrustMeAnno && varargElemType != null &&
 types.isReifiable(varargElemType)) {
 warnUnsafeVararg(tree,
 "varargs.redundant.trustme.anno",
 syms.trustMeType.tsym,
-diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));
+diags.fragment(Fragments.VarargsTrustmeOnReifiableVarargs(varargElemType)));
 }
 else if (!hasTrustMeAnno && varargElemType != null &&
 !types.isReifiable(varargElemType)) {
 warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);
 }
 // non-varargs call to varargs method
 Type varParam = owntype.getParameterTypes().last();
 Type lastArg = argtypes.last();
 if (types.isSubtypeUnchecked(lastArg, types.elemtype(varParam)) &&
 !types.isSameType(types.erasure(varParam), types.erasure(lastArg)))
-log.warning(argtrees.last().pos(), "inexact.non-varargs.call",
+log.warning(argtrees.last().pos(),
-types.elemtype(varParam), varParam);
+Warnings.InexactNonVarargsCall(types.elemtype(varParam),varParam));
 }
 }
 if (useVarargs) {
 Type argtype = owntype.getParameterTypes().last();
 if (!types.isReifiable(argtype) &&
 case TYP:
 if (sym.isLocal()) {
 mask = LocalClassFlags;
 if ((sym.owner.flags_field & STATIC) == 0 &&
 (flags & ENUM) != 0)
-log.error(pos, "enums.must.be.static");
+log.error(pos, Errors.EnumsMustBeStatic);
 } else if (sym.owner.kind == TYP) {
 mask = MemberClassFlags;
 if (sym.owner.owner.kind == PCK ||
 (sym.owner.flags_field & STATIC) != 0)
 mask |= STATIC;
 else if ((flags & ENUM) != 0)
-log.error(pos, "enums.must.be.static");
+log.error(pos, Errors.EnumsMustBeStatic);
 // Nested interfaces and enums are always STATIC (Spec ???)
 if ((flags & (INTERFACE | ENUM)) != 0 ) implicit = STATIC;
 } else {
 mask = ClassFlags;
 }
 throw new AssertionError();
 }
 long illegal = flags & ExtendedStandardFlags & ~mask;
 if (illegal != 0) {
 if ((illegal & INTERFACE) != 0) {
-log.error(pos, "intf.not.allowed.here");
+log.error(pos, Errors.IntfNotAllowedHere);
 mask |= INTERFACE;
 }
 else {
 log.error(pos,
-"mod.not.allowed.here", asFlagSet(illegal));
+Errors.ModNotAllowedHere(asFlagSet(illegal)));
 }
 }
 else if ((sym.kind == TYP ||
 // ISSUE: Disallowing abstract&private is no longer appropriate
 // in the presence of inner classes. Should it be deleted here?
 Type incompatibleArg = firstIncompatibleTypeArg(tree.type);
 if (incompatibleArg != null) {
 for (JCTree arg : tree.arguments) {
 if (arg.type == incompatibleArg) {
-log.error(arg, "not.within.bounds", incompatibleArg, forms.head);
+log.error(arg, Errors.NotWithinBounds(incompatibleArg, forms.head));
 }
 forms = forms.tail;
 }
 }
 }
 // Check that this type is either fully parameterized, or
 // not parameterized at all.
 if (tree.type.getEnclosingType().isRaw())
-log.error(tree.pos(), "improperly.formed.type.inner.raw.param");
+log.error(tree.pos(), Errors.ImproperlyFormedTypeInnerRawParam);
 if (tree.clazz.hasTag(SELECT))
 visitSelectInternal((JCFieldAccess)tree.clazz);
 }
 }
 visitSelectInternal(tree);
 // Check that this type is either fully parameterized, or
 // not parameterized at all.
 if (tree.selected.type.isParameterized() && tree.type.tsym.type.getTypeArguments().nonEmpty())
-log.error(tree.pos(), "improperly.formed.type.param.missing");
+log.error(tree.pos(), Errors.ImproperlyFormedTypeParamMissing);
 }
 }
 public void visitSelectInternal(JCFieldAccess tree) {
 if (tree.type.tsym.isStatic() &&
 tree.selected.type.isParameterized()) {
 // The enclosing type is not a class, so we are
 // looking at a static member type.  However, the
 // qualifying expression is parameterized.
-log.error(tree.pos(), "cant.select.static.class.from.param.type");
+log.error(tree.pos(), Errors.CantSelectStaticClassFromParamType);
 } else {
 // otherwise validate the rest of the expression
 tree.selected.accept(this);
 }
 }
 }
 @Override
 public void visitTypeIdent(JCPrimitiveTypeTree that) {
 if (that.type.hasTag(TypeTag.VOID)) {
-log.error(that.pos(), "void.not.allowed.here");
+log.error(that.pos(), Errors.VoidNotAllowedHere);
 }
 super.visitTypeIdent(that);
 }
 /** Default visitor method: do nothing.
 tree.type.hasTag(CLASS) &&
 !TreeInfo.isDiamond(tree) &&
 !withinAnonConstr(env) &&
 tree.type.isRaw()) {
 log.warning(LintCategory.RAW,
-tree.pos(), "raw.class.use", tree.type, tree.type.tsym.type);
+tree.pos(), Warnings.RawClassUse(tree.type, tree.type.tsym.type));
 }
 }
 //where
 private boolean withinAnonConstr(Env<AttrContext> env) {
 return env.enclClass.name.isEmpty() &&
 /** A customized "cannot override" error message.
 *  @param m      The overriding method.
 *  @param other  The overridden method.
 *  @return       An internationalized string.
 */
-Object cannotOverride(MethodSymbol m, MethodSymbol other) {
+Fragment cannotOverride(MethodSymbol m, MethodSymbol other) {
-String key;
+Symbol mloc = m.location();
+Symbol oloc = other.location();
 if ((other.owner.flags() & INTERFACE) == 0)
-key = "cant.override";
+return Fragments.CantOverride(m, mloc, other, oloc);
 else if ((m.owner.flags() & INTERFACE) == 0)
-key = "cant.implement";
+return Fragments.CantImplement(m, mloc, other, oloc);
 else
-key = "clashes.with";
+return Fragments.ClashesWith(m, mloc, other, oloc);
-return diags.fragment(key, m, m.location(), other, other.location());
 }
 /** A customized "override" warning message.
 *  @param m      The overriding method.
 *  @param other  The overridden method.
 *  @return       An internationalized string.
 */
-Object uncheckedOverrides(MethodSymbol m, MethodSymbol other) {
+Fragment uncheckedOverrides(MethodSymbol m, MethodSymbol other) {
-String key;
+Symbol mloc = m.location();
+Symbol oloc = other.location();
 if ((other.owner.flags() & INTERFACE) == 0)
-key = "unchecked.override";
+return Fragments.UncheckedOverride(m, mloc, other, oloc);
 else if ((m.owner.flags() & INTERFACE) == 0)
-key = "unchecked.implement";
+return Fragments.UncheckedImplement(m, mloc, other, oloc);
 else
-key = "unchecked.clash.with";
+return Fragments.UncheckedClashWith(m, mloc, other, oloc);
-return diags.fragment(key, m, m.location(), other, other.location());
 }
 /** A customized "override" warning message.
 *  @param m      The overriding method.
 *  @param other  The overridden method.
 *  @return       An internationalized string.
 */
-Object varargsOverrides(MethodSymbol m, MethodSymbol other) {
+Fragment varargsOverrides(MethodSymbol m, MethodSymbol other) {
-String key;
+Symbol mloc = m.location();
+Symbol oloc = other.location();
 if ((other.owner.flags() & INTERFACE) == 0)
-key = "varargs.override";
+return Fragments.VarargsOverride(m, mloc, other, oloc);
 else  if ((m.owner.flags() & INTERFACE) == 0)
-key = "varargs.implement";
+return Fragments.VarargsImplement(m, mloc, other, oloc);
 else
-key = "varargs.clash.with";
+return Fragments.VarargsClashWith(m, mloc, other, oloc);
-return diags.fragment(key, m, m.location(), other, other.location());
 }
 /** Check that this method conforms with overridden method 'other'.
 *  where `origin' is the class where checking started.
 *  Complications:
 }
 // Error if static method overrides instance method (JLS 8.4.6.2).
 if ((m.flags() & STATIC) != 0 &&
 (other.flags() & STATIC) == 0) {
-log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.static",
+log.error(TreeInfo.diagnosticPositionFor(m, tree),
-cannotOverride(m, other));
+Errors.OverrideStatic(cannotOverride(m, other)));
 m.flags_field |= BAD_OVERRIDE;
 return;
 }
 // Error if instance method overrides static or final
 // method (JLS 8.4.6.1).
 if ((other.flags() & FINAL) != 0 ||
 (m.flags() & STATIC) == 0 &&
 (other.flags() & STATIC) != 0) {
-log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.meth",
+log.error(TreeInfo.diagnosticPositionFor(m, tree),
-cannotOverride(m, other),
+Errors.OverrideMeth(cannotOverride(m, other),
-asFlagSet(other.flags() & (FINAL | STATIC)));
+asFlagSet(other.flags() & (FINAL | STATIC))));
 m.flags_field |= BAD_OVERRIDE;
 return;
 }
 if ((m.owner.flags() & ANNOTATION) != 0) {
 return;
 }
 // Error if overriding method has weaker access (JLS 8.4.6.3).
 if (protection(m.flags()) > protection(other.flags())) {
-log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.weaker.access",
+log.error(TreeInfo.diagnosticPositionFor(m, tree),
-cannotOverride(m, other),
 (other.flags() & AccessFlags) == 0 ?
-"package" :
+Errors.OverrideWeakerAccess(cannotOverride(m, other),
-asFlagSet(other.flags() & AccessFlags));
+"package") :
+Errors.OverrideWeakerAccess(cannotOverride(m, other),
+asFlagSet(other.flags() & AccessFlags)));
 m.flags_field |= BAD_OVERRIDE;
 return;
 }
 Type mt = types.memberType(origin.type, m);
 boolean resultTypesOK =
 types.returnTypeSubstitutable(mt, ot, otres, overrideWarner);
 if (!resultTypesOK) {
 if ((m.flags() & STATIC) != 0 && (other.flags() & STATIC) != 0) {
 log.error(TreeInfo.diagnosticPositionFor(m, tree),
 Errors.OverrideIncompatibleRet(Fragments.CantHide(m, m.location(), other,
 other.location()), mtres, otres));
 m.flags_field |= BAD_OVERRIDE;
 } else {
 log.error(TreeInfo.diagnosticPositionFor(m, tree),
-"override.incompatible.ret",
+Errors.OverrideIncompatibleRet(cannotOverride(m, other), mtres, otres));
-cannotOverride(m, other),
-mtres, otres);
 m.flags_field |= BAD_OVERRIDE;
 }
 return;
 } else if (overrideWarner.hasNonSilentLint(LintCategory.UNCHECKED)) {
 warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree),
 List<Type> otthrown = types.subst(ot.getThrownTypes(), otvars, mtvars);
 List<Type> unhandledErased = unhandled(mt.getThrownTypes(), types.erasure(otthrown));
 List<Type> unhandledUnerased = unhandled(mt.getThrownTypes(), otthrown);
 if (unhandledErased.nonEmpty()) {
 log.error(TreeInfo.diagnosticPositionFor(m, tree),
-"override.meth.doesnt.throw",
+Errors.OverrideMethDoesntThrow(cannotOverride(m, other), unhandledUnerased.head));
-cannotOverride(m, other),
-unhandledUnerased.head);
 m.flags_field |= BAD_OVERRIDE;
 return;
 }
 else if (unhandledUnerased.nonEmpty()) {
 warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree),
 // Optional warning if varargs don't agree
 if ((((m.flags() ^ other.flags()) & Flags.VARARGS) != 0)
 && lint.isEnabled(LintCategory.OVERRIDES)) {
 log.warning(TreeInfo.diagnosticPositionFor(m, tree),
 ((m.flags() & Flags.VARARGS) != 0)
-? "override.varargs.missing"
+? Warnings.OverrideVarargsMissing(varargsOverrides(m, other))
-: "override.varargs.extra",
+: Warnings.OverrideVarargsExtra(varargsOverrides(m, other)));
-varargsOverrides(m, other));
 }
 // Warn if instance method overrides bridge method (compiler spec ??)
 if ((other.flags() & BRIDGE) != 0) {
-log.warning(TreeInfo.diagnosticPositionFor(m, tree), "override.bridge",
+log.warning(TreeInfo.diagnosticPositionFor(m, tree),
-uncheckedOverrides(m, other));
+Warnings.OverrideBridge(uncheckedOverrides(m, other)));
 }
 // Warn if a deprecated method overridden by a non-deprecated one.
 if (!isDeprecatedOverrideIgnorable(other, origin)) {
 Lint prevLint = setLint(lint.augment(m));
 types,
 true) != s2)
 continue;
 Type st2 = types.memberType(t2, s2);
 if (types.overrideEquivalent(st1, st2))
-log.error(pos, "concrete.inheritance.conflict",
+log.error(pos,
-s1, t1, s2, t2, sup);
+Errors.ConcreteInheritanceConflict(s1, t1, s2, t2, sup));
 }
 }
 }
 }
 }
 !rt2.isPrimitiveOrVoid() &&
 (types.covariantReturnType(rt1, rt2, types.noWarnings) ||
 types.covariantReturnType(rt2, rt1, types.noWarnings)) ||
 checkCommonOverriderIn(s1,s2,site);
 if (!compat) {
-log.error(pos, "types.incompatible.diff.ret",
+log.error(pos, Errors.TypesIncompatibleDiffRet(t1, t2, s2.name +
-t1, t2, s2.name +
+"(" + types.memberType(t2, s2).getParameterTypes() + ")"));
-"(" + types.memberType(t2, s2).getParameterTypes() + ")");
 return s2;
 }
 } else if (checkNameClash((ClassSymbol)site.tsym, s1, s2) &&
 !checkCommonOverriderIn(s1, s2, site)) {
 log.error(pos, Errors.NameClashSameErasureNoOverride(
 */
 void checkOverride(Env<AttrContext> env, JCMethodDecl tree, MethodSymbol m) {
 ClassSymbol origin = (ClassSymbol)m.owner;
 if ((origin.flags() & ENUM) != 0 && names.finalize.equals(m.name))
 if (m.overrides(syms.enumFinalFinalize, origin, types, false)) {
-log.error(tree.pos(), "enum.no.finalize");
+log.error(tree.pos(), Errors.EnumNoFinalize);
 return;
 }
 for (Type t = origin.type; t.hasTag(CLASS);
 t = types.supertype(t)) {
 if (t != origin.type) {
 boolean overridesHashCode = types.implementation(hashCodeAtObject,
 someClass, false, equalsHasCodeFilter) != hashCodeAtObject;
 if (overridesEquals && !overridesHashCode) {
 log.warning(LintCategory.OVERRIDES, pos,
-"override.equals.but.not.hashcode", someClass);
+Warnings.OverrideEqualsButNotHashcode(someClass));
 }
 }
 }
 public void checkModuleName (JCModuleDecl tree) {
 MethodSymbol undef = types.firstUnimplementedAbstract(c);
 if (undef != null) {
 MethodSymbol undef1 =
 new MethodSymbol(undef.flags(), undef.name,
 types.memberType(c.type, undef), undef.owner);
-log.error(pos, "does.not.override.abstract",
+log.error(pos,
-c, undef1, undef1.location());
+Errors.DoesNotOverrideAbstract(c, undef1, undef1.location()));
 }
 }
 void checkNonCyclicDecl(JCClassDecl tree) {
 CycleChecker cc = new CycleChecker();
 if  (t.hasTag(TYPEVAR) && (t.tsym.flags() & UNATTRIBUTED) != 0)
 return;
 if (seen.contains(t)) {
 tv = (TypeVar)t;
 tv.bound = types.createErrorType(t);
-log.error(pos, "cyclic.inheritance", t);
+log.error(pos, Errors.CyclicInheritance(t));
 } else if (t.hasTag(TYPEVAR)) {
 tv = (TypeVar)t;
 seen = seen.prepend(tv);
 for (Type b : types.getBounds(tv))
 checkNonCyclic1(pos, b, seen);
 return complete;
 }
 /** Note that we found an inheritance cycle. */
 private void noteCyclic(DiagnosticPosition pos, ClassSymbol c) {
-log.error(pos, "cyclic.inheritance", c);
+log.error(pos, Errors.CyclicInheritance(c));
 for (List<Type> l=types.interfaces(c.type); l.nonEmpty(); l=l.tail)
 l.head = types.createErrorType((ClassSymbol)l.head.tsym, Type.noType);
 Type st = types.supertype(c.type);
 if (st.hasTag(CLASS))
 ((ClassType)c.type).supertype_field = types.createErrorType((ClassSymbol)st.tsym, Type.noType);
 //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.hasSameArgs(s.erasure(types), sym.erasure(types))) {
 log.error(pos,
-"name.clash.same.erasure.no.hide",
+Errors.NameClashSameErasureNoHide(sym, sym.location(), s, s.location()));
-sym, sym.location(),
-s, s.location());
 return;
 } else {
 checkPotentiallyAmbiguousOverloads(pos, site, sym, (MethodSymbol)s);
 }
 }
 if (potentiallyAmbiguous) {
 //we found two incompatible functional interfaces with same arity
 //this means a call site passing an implicit lambda would be ambigiuous
 msym1.flags_field |= POTENTIALLY_AMBIGUOUS;
 msym2.flags_field |= POTENTIALLY_AMBIGUOUS;
-log.warning(LintCategory.OVERLOADS, pos, "potentially.ambiguous.overload",
+log.warning(LintCategory.OVERLOADS, pos,
-msym1, msym1.location(),
+Warnings.PotentiallyAmbiguousOverload(msym1, msym1.location(),
-msym2, msym2.location());
+msym2, msym2.location()));
 return;
 }
 }
 }
 if (!types.isSubtype(sym.owner.type, syms.serializableType) &&
 isEffectivelyNonPublic(sym)) {
 if (isLambda) {
 if (belongsToRestrictedPackage(sym)) {
 log.warning(LintCategory.SERIAL, tree.pos(),
-"access.to.member.from.serializable.lambda", sym);
+Warnings.AccessToMemberFromSerializableLambda(sym));
 }
 } else {
 log.warning(tree.pos(),
-"access.to.member.from.serializable.element", sym);
+Warnings.AccessToMemberFromSerializableElement(sym));
 }
 }
 }
 }
 /** Report a conflict between a user symbol and a synthetic symbol.
 */
 private void syntheticError(DiagnosticPosition pos, Symbol sym) {
 if (!sym.type.isErroneous()) {
-log.error(pos, "synthetic.name.conflict", sym, sym.location());
+log.error(pos, Errors.SyntheticNameConflict(sym, sym.location()));
 }
 }
 /** Check that class c does not implement directly or indirectly
 *  the same parameterized interface with two different argument lists.
 Type oldit = seensofar.put(it.tsym, it);
 if (oldit != null) {
 List<Type> oldparams = oldit.allparams();
 List<Type> newparams = it.allparams();
 if (!types.containsTypeEquivalent(oldparams, newparams))
-log.error(pos, "cant.inherit.diff.arg",
+log.error(pos,
-it.tsym, Type.toString(oldparams),
+Errors.CantInheritDiffArg(it.tsym,
-Type.toString(newparams));
+Type.toString(oldparams),
+Type.toString(newparams)));
 }
 checkClassBounds(pos, seensofar, it);
 }
 Type st = types.supertype(type);
 if (st != Type.noType) checkClassBounds(pos, seensofar, st);
 /** Enter interface into into set.
 *  If it existed already, issue a "repeated interface" error.
 */
 void checkNotRepeated(DiagnosticPosition pos, Type it, Set<Type> its) {
 if (its.contains(it))
-log.error(pos, "repeated.interface");
+log.error(pos, Errors.RepeatedInterface);
 else {
 its.add(it);
 }
 }
 if (types.cvarLowerBound(type).tsym == syms.classType.tsym) return;
 if (types.isArray(type) && !types.isArray(types.elemtype(type))) {
 validateAnnotationType(pos, types.elemtype(type));
 return;
 }
-log.error(pos, "invalid.annotation.member.type");
+log.error(pos, Errors.InvalidAnnotationMemberType);
 }
 /**
 * "It is also a compile-time error if any method declared in an
 * annotation type has a signature that is override-equivalent to
 Scope s = sup.tsym.members();
 for (Symbol sym : s.getSymbolsByName(m.name)) {
 if (sym.kind == MTH &&
 (sym.flags() & (PUBLIC | PROTECTED)) != 0 &&
 types.overrideEquivalent(m.type, sym.type))
-log.error(pos, "intf.annotation.member.clash", sym, sup);
+log.error(pos, Errors.IntfAnnotationMemberClash(sym, sup));
 }
 }
 }
 /** Check the annotations of a symbol.
 */
 private void validateAnnotation(JCAnnotation a, Symbol s) {
 validateAnnotationTree(a);
 if (a.type.tsym.isAnnotationType() && !annotationApplicable(a, s))
-log.error(a.pos(), "annotation.type.not.applicable");
+log.error(a.pos(), Errors.AnnotationTypeNotApplicable);
 if (a.annotationType.type.tsym == syms.functionalInterfaceType.tsym) {
 if (s.kind != TYP) {
-log.error(a.pos(), "bad.functional.intf.anno");
+log.error(a.pos(), Errors.BadFunctionalIntfAnno);
 } else if (!s.isInterface() || (s.flags() & ANNOTATION) != 0) {
-log.error(a.pos(), "bad.functional.intf.anno.1", diags.fragment("not.a.functional.intf", s));
+log.error(a.pos(), Errors.BadFunctionalIntfAnno1(Fragments.NotAFunctionalIntf(s)));
 }
 }
 }
 public void validateTypeAnnotation(JCAnnotation a, boolean isTypeParameter) {
 Symbol sym = container.members().findFirst(names.value);
 if (sym != null && sym.kind == MTH) {
 MethodSymbol m = (MethodSymbol) sym;
 Type ret = m.getReturnType();
 if (!(ret.hasTag(ARRAY) && types.isSameType(((ArrayType)ret).elemtype, contained.type))) {
-log.error(pos, "invalid.repeatable.annotation.value.return",
+log.error(pos,
-container, ret, types.makeArrayType(contained.type));
+Errors.InvalidRepeatableAnnotationValueReturn(container,
+ret,
+types.makeArrayType(contained.type)));
 }
 } else {
-log.error(pos, "invalid.repeatable.annotation.no.value", container);
+log.error(pos, Errors.InvalidRepeatableAnnotationNoValue(container));
 }
 }
 private void validateRetention(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
 Attribute.RetentionPolicy containerRetention = types.getRetention(container);
 if (containerRetention == Attribute.RetentionPolicy.SOURCE)  {
 error = true;
 }
 }
 if (error ) {
-log.error(pos, "invalid.repeatable.annotation.retention",
+log.error(pos,
-container, containerRetention,
+Errors.InvalidRepeatableAnnotationRetention(container,
-contained, containedRetention);
+containerRetention.name(),
+contained,
+containedRetention.name()));
 }
 }
 private void validateDocumented(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.documentedType.tsym) != null) {
 if (container.attribute(syms.documentedType.tsym) == null) {
-log.error(pos, "invalid.repeatable.annotation.not.documented", container, contained);
+log.error(pos, Errors.InvalidRepeatableAnnotationNotDocumented(container, contained));
 }
 }
 }
 private void validateInherited(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.inheritedType.tsym) != null) {
 if (container.attribute(syms.inheritedType.tsym) == null) {
-log.error(pos, "invalid.repeatable.annotation.not.inherited", container, contained);
+log.error(pos, Errors.InvalidRepeatableAnnotationNotInherited(container, contained));
 }
 }
 }
 private void validateTarget(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
 containedTargets.add(e.value.name);
 }
 }
 if (!isTargetSubsetOf(containerTargets, containedTargets)) {
-log.error(pos, "invalid.repeatable.annotation.incompatible.target", container, contained);
+log.error(pos, Errors.InvalidRepeatableAnnotationIncompatibleTarget(container, contained));
 }
 }
 /* get a set of names for the default target */
 private Set<Name> getDefaultTargetSet() {
 for(Symbol elm : scope.getSymbols()) {
 if (elm.name != names.value &&
 elm.kind == MTH &&
 ((MethodSymbol)elm).defaultValue == null) {
 log.error(pos,
-"invalid.repeatable.annotation.elem.nondefault",
+Errors.InvalidRepeatableAnnotationElemNondefault(container, elm));
-container,
-elm);
 }
 }
 }
 /** Is s a method symbol that overrides a method in a superclass? */
 JCAssign assign = (JCAssign)arg;
 Symbol m = TreeInfo.symbol(assign.lhs);
 if (m == null || m.type.isErroneous()) continue;
 if (!elements.remove(m)) {
 isValid = false;
-log.error(assign.lhs.pos(), "duplicate.annotation.member.value",
+log.error(assign.lhs.pos(),
-m.name, a.type);
+Errors.DuplicateAnnotationMemberValue(m.name, a.type));
 }
 }
 // all the remaining ones better have default values
 List<Name> missingDefaults = List.nil();
 JCNewArray na = (JCNewArray) rhs;
 Set<Symbol> targets = new HashSet<>();
 for (JCTree elem : na.elems) {
 if (!targets.add(TreeInfo.symbol(elem))) {
 isValid = false;
-log.error(elem.pos(), "repeated.annotation.target");
+log.error(elem.pos(), Errors.RepeatedAnnotationTarget);
 }
 }
 return isValid;
 }
 if (lint.isEnabled(LintCategory.DEP_ANN) && s.isDeprecatableViaAnnotation() &&
 (s.flags() & DEPRECATED) != 0 &&
 !syms.deprecatedType.isErroneous() &&
 s.attribute(syms.deprecatedType.tsym) == null) {
 log.warning(LintCategory.DEP_ANN,
-pos, "missing.deprecated.annotation");
+pos, Warnings.MissingDeprecatedAnnotation);
 }
 // Note: @Deprecated has no effect on local variables, parameters and package decls.
 if (lint.isEnabled(LintCategory.DEPRECATION) && !s.isDeprecatableViaAnnotation()) {
 if (!syms.deprecatedType.isErroneous() && s.attribute(syms.deprecatedType.tsym) != null) {
 log.warning(LintCategory.DEPRECATION, pos,
-"deprecated.annotation.has.no.effect", Kinds.kindName(s));
+Warnings.DeprecatedAnnotationHasNoEffect(Kinds.kindName(s)));
 }
 }
 }
 void checkDeprecated(final DiagnosticPosition pos, final Symbol other, final Symbol s) {
 }
 void checkSunAPI(final DiagnosticPosition pos, final Symbol s) {
 if ((s.flags() & PROPRIETARY) != 0) {
 deferredLintHandler.report(() -> {
-log.mandatoryWarning(pos, "sun.proprietary", s);
+log.mandatoryWarning(pos, Warnings.SunProprietary(s));
 });
 }
 }
 void checkProfile(final DiagnosticPosition pos, final Symbol s) {
 if (profile != Profile.DEFAULT && (s.flags() & NOT_IN_PROFILE) != 0) {
-log.error(pos, "not.in.profile", s, profile);
+log.error(pos, Errors.NotInProfile(s, profile));
 }
 }
 /* *************************************************************************
 * Check for recursive annotation elements.
 void checkNonCyclicElementsInternal(DiagnosticPosition pos, TypeSymbol tsym) {
 if ((tsym.flags_field & ACYCLIC_ANN) != 0)
 return;
 if ((tsym.flags_field & LOCKED) != 0) {
-log.error(pos, "cyclic.annotation.element");
+log.error(pos, Errors.CyclicAnnotationElement(tsym));
 return;
 }
 try {
 tsym.flags_field |= LOCKED;
 for (Symbol s : tsym.members().getSymbols(NON_RECURSIVE)) {
 private void checkCyclicConstructor(JCClassDecl tree, Symbol ctor,
 Map<Symbol,Symbol> callMap) {
 if (ctor != null && (ctor.flags_field & ACYCLIC) == 0) {
 if ((ctor.flags_field & LOCKED) != 0) {
 log.error(TreeInfo.diagnosticPositionFor(ctor, tree),
-"recursive.ctor.invocation");
+Errors.RecursiveCtorInvocation);
 } else {
 ctor.flags_field |= LOCKED;
 checkCyclicConstructor(tree, callMap.remove(ctor), callMap);
 ctor.flags_field &= ~LOCKED;
 }
 * Check for empty statements after if
 */
 void checkEmptyIf(JCIf tree) {
 if (tree.thenpart.hasTag(SKIP) && tree.elsepart == null &&
 lint.isEnabled(LintCategory.EMPTY))
-log.warning(LintCategory.EMPTY, tree.thenpart.pos(), "empty.if");
+log.warning(LintCategory.EMPTY, tree.thenpart.pos(), Warnings.EmptyIf);
 }
 /** Check that symbol is unique in given scope.
 *  @param pos           Position for error reporting.
 *  @param sym           The symbol.
 /** Report duplicate declaration error.
 */
 void duplicateErasureError(DiagnosticPosition pos, Symbol sym1, Symbol sym2) {
 if (!sym1.type.isErroneous() && !sym2.type.isErroneous()) {
-log.error(pos, "name.clash.same.erasure", sym1, sym2);
+log.error(pos, Errors.NameClashSameErasure(sym1, sym2));
 }
 }
 /**Check that types imported through the ordinary imports don't clash with types imported
 * by other (static or ordinary) imports. Note that two static imports may import two clashing
 if (clashing == null && !staticImport) {
 clashing = staticallyImportedSoFar.findFirst(sym.name, duplicates);
 }
 if (clashing != null) {
 if (staticImport)
-log.error(pos, "already.defined.static.single.import", clashing);
+log.error(pos, Errors.AlreadyDefinedStaticSingleImport(clashing));
 else
-log.error(pos, "already.defined.single.import", clashing);
+log.error(pos, Errors.AlreadyDefinedSingleImport(clashing));
 return false;
 }
 clashing = topLevelScope.findFirst(sym.name, duplicates);
 if (clashing != null) {
-log.error(pos, "already.defined.this.unit", clashing);
+log.error(pos, Errors.AlreadyDefinedThisUnit(clashing));
 return false;
 }
 return true;
 }
 /** Check that a qualified name is in canonical form (for import decls).
 */
 public void checkCanonical(JCTree tree) {
 if (!isCanonical(tree))
-log.error(tree.pos(), "import.requires.canonical",
+log.error(tree.pos(),
-TreeInfo.symbol(tree));
+Errors.ImportRequiresCanonical(TreeInfo.symbol(tree)));
 }
 // where
 private boolean isCanonical(JCTree tree) {
 while (tree.hasTag(SELECT)) {
 JCFieldAccess s = (JCFieldAccess) tree;
 if (lint.isEnabled(Lint.LintCategory.AUXILIARYCLASS) &&
 (c.flags() & AUXILIARY) != 0 &&
 rs.isAccessible(env, c) &&
 !fileManager.isSameFile(c.sourcefile, env.toplevel.sourcefile))
 {
-log.warning(pos, "auxiliary.class.accessed.from.outside.of.its.source.file",
+log.warning(pos,
-c, c.sourcefile);
+Warnings.AuxiliaryClassAccessedFromOutsideOfItsSourceFile(c, c.sourcefile));
 }
 }
 private class ConversionWarner extends Warner {
 final String uncheckedKey;
 if (a.annotationType.type.tsym == syms.functionalInterfaceType.tsym) {
 pos = a.pos();
 break;
 }
 }
-log.error(pos, "bad.functional.intf.anno.1", ex.getDiagnostic());
+log.error(pos, Errors.BadFunctionalIntfAnno1(ex.getDiagnostic()));
 }
 }
 }
 public void checkImportsResolvable(final JCCompilationUnit toplevel) {
 if (select.name == names.asterisk || (origin = TreeInfo.symbol(select.selected)) == null || origin.kind != TYP)
 continue;
 TypeSymbol site = (TypeSymbol) TreeInfo.symbol(select.selected);
 if (!checkTypeContainsImportableElement(site, site, toplevel.packge, select.name, new HashSet<Symbol>())) {
-log.error(imp.pos(), "cant.resolve.location",
+log.error(imp.pos(),
-KindName.STATIC,
+Errors.CantResolveLocation(KindName.STATIC,
-select.name, List.<Type>nil(), List.<Type>nil(),
+select.name,
-Kinds.typeKindName(TreeInfo.symbol(select.selected).type),
+null,
-TreeInfo.symbol(select.selected).type);
+null,
+Fragments.Location(kindName(site),
+site,
+null)));
 }
 }
 }
 // Check that packages imported are in scope (JLS 7.4.3, 6.3, 6.5.3.1, 6.5.3.2)
 if (Convert.packagePart(known.fullname) == tsym.flatName())
 continue OUTER;
 }
 }
 if (tsym.kind == PCK && tsym.members().isEmpty() && !tsym.exists()) {
-log.error(DiagnosticFlag.RESOLVE_ERROR, imp.pos, "doesnt.exist", tsym);
+log.error(DiagnosticFlag.RESOLVE_ERROR, imp.pos, Errors.DoesntExist(tsym));
 }
 }
 }
 }

changeset 45504	ea7475564d07
parent 45413	75202c6b2c35
child 45756	67f4f8f4d34a