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

equal deleted inserted replaced

-:d23ae2d67a5d
+:ea7475564d07
 import static com.sun.tools.javac.resources.CompilerProperties.Fragments.Diamond;
 import static com.sun.tools.javac.resources.CompilerProperties.Fragments.DiamondInvalidArg;
 import static com.sun.tools.javac.resources.CompilerProperties.Fragments.DiamondInvalidArgs;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
+import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.DefinedBy.Api;
 Type owntype;
 boolean shouldCheck = !found.hasTag(ERROR) &&
 !resultInfo.pt.hasTag(METHOD) &&
 !resultInfo.pt.hasTag(FORALL);
 if (shouldCheck && !ownkind.subset(resultInfo.pkind)) {
-log.error(tree.pos(), "unexpected.type",
+log.error(tree.pos(),
-resultInfo.pkind.kindNames(),
+Errors.UnexpectedType(resultInfo.pkind.kindNames(),
-ownkind.kindNames());
+ownkind.kindNames()));
 owntype = types.createErrorType(found);
 } else if (allowPoly && inferenceContext.free(found)) {
 //delay the check if there are inference variables in the found type
 //this means we are dealing with a partially inferred poly expression
 owntype = shouldCheck ? resultInfo.pt : found;
 ||
 !((base == null ||
 (base.hasTag(IDENT) && TreeInfo.name(base) == names._this)) &&
 isAssignableAsBlankFinal(v, env)))) {
 if (v.isResourceVariable()) { //TWR resource
-log.error(pos, "try.resource.may.not.be.assigned", v);
+log.error(pos, Errors.TryResourceMayNotBeAssigned(v));
 } else {
-log.error(pos, "cant.assign.val.to.final.var", v);
+log.error(pos, Errors.CantAssignValToFinalVar(v));
 }
 }
 }
 /** Does tree represent a static reference to an identifier?
 boolean interfaceExpected,
 boolean checkExtensible) {
 final DiagnosticPosition pos = tree.hasTag(TYPEAPPLY) ?
 (((JCTypeApply) tree).clazz).pos() : tree.pos();
 if (t.tsym.isAnonymous()) {
-log.error(pos, "cant.inherit.from.anon");
+log.error(pos, Errors.CantInheritFromAnon);
 return types.createErrorType(t);
 }
 if (t.isErroneous())
 return t;
 if (t.hasTag(TYPEVAR) && !classExpected && !interfaceExpected) {
 // check that type variable is already visible
 if (t.getUpperBound() == null) {
-log.error(pos, "illegal.forward.ref");
+log.error(pos, Errors.IllegalForwardRef);
 return types.createErrorType(t);
 }
 } else {
 t = chk.checkClassType(pos, t, checkExtensible);
 }
 if (interfaceExpected && (t.tsym.flags() & INTERFACE) == 0) {
-log.error(pos, "intf.expected.here");
+log.error(pos, Errors.IntfExpectedHere);
 // return errType is necessary since otherwise there might
 // be undetected cycles which cause attribution to loop
 return types.createErrorType(t);
 } else if (checkExtensible &&
 classExpected &&
 (t.tsym.flags() & INTERFACE) != 0) {
-log.error(pos, "no.intf.expected.here");
+log.error(pos, Errors.NoIntfExpectedHere);
 return types.createErrorType(t);
 }
 if (checkExtensible &&
 ((t.tsym.flags() & FINAL) != 0)) {
 log.error(pos,
-"cant.inherit.from.final", t.tsym);
+Errors.CantInheritFromFinal(t.tsym));
 }
 chk.checkNonCyclic(pos, t);
 return t;
 }
 chk.checkOverrideClashes(tree.pos(), env.enclClass.type, m);
 }
 chk.checkOverride(env, tree, m);
 if (isDefaultMethod && types.overridesObjectMethod(m.enclClass(), m)) {
-log.error(tree, "default.overrides.object.member", m.name, Kinds.kindName(m.location()), m.location());
+log.error(tree, Errors.DefaultOverridesObjectMember(m.name, Kinds.kindName(m.location()), m.location()));
 }
 // Enter all type parameters into the local method scope.
 for (List<JCTypeParameter> l = tree.typarams; l.nonEmpty(); l = l.tail)
 localEnv.info.scope.enterIfAbsent(l.head.type.tsym);
 (tree.params.nonEmpty() ||
 tree.recvparam != null))
 log.error(tree.params.nonEmpty() ?
 tree.params.head.pos() :
 tree.recvparam.pos(),
-"intf.annotation.members.cant.have.params");
+Errors.IntfAnnotationMembersCantHaveParams);
 // Attribute all value parameters.
 for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
 attribStat(l.head, localEnv);
 }
 // annotation method checks
 if ((owner.flags() & ANNOTATION) != 0) {
 // annotation method cannot have throws clause
 if (tree.thrown.nonEmpty()) {
 log.error(tree.thrown.head.pos(),
-"throws.not.allowed.in.intf.annotation");
+Errors.ThrowsNotAllowedInIntfAnnotation);
 }
 // annotation method cannot declare type-parameters
 if (tree.typarams.nonEmpty()) {
 log.error(tree.typarams.head.pos(),
-"intf.annotation.members.cant.have.type.params");
+Errors.IntfAnnotationMembersCantHaveTypeParams);
 }
 // validate annotation method's return type (could be an annotation type)
 chk.validateAnnotationType(tree.restype);
 // ensure that annotation method does not clash with members of Object/Annotation
 chk.validateAnnotationMethod(tree.pos(), m);
 // abstract, native, or interface methods, or for methods
 // in a retrofit signature class.
 if (tree.defaultValue != null) {
 if ((owner.flags() & ANNOTATION) == 0)
 log.error(tree.pos(),
-"default.allowed.in.intf.annotation.member");
+Errors.DefaultAllowedInIntfAnnotationMember);
 }
 if (isDefaultMethod || (tree.sym.flags() & (ABSTRACT | NATIVE)) == 0)
-log.error(tree.pos(), "missing.meth.body.or.decl.abstract");
+log.error(tree.pos(), Errors.MissingMethBodyOrDeclAbstract);
 } else if ((tree.sym.flags() & (ABSTRACT|DEFAULT|PRIVATE)) == ABSTRACT) {
 if ((owner.flags() & INTERFACE) != 0) {
-log.error(tree.body.pos(), "intf.meth.cant.have.body");
+log.error(tree.body.pos(), Errors.IntfMethCantHaveBody);
 } else {
-log.error(tree.pos(), "abstract.meth.cant.have.body");
+log.error(tree.pos(), Errors.AbstractMethCantHaveBody);
 }
 } else if ((tree.mods.flags & NATIVE) != 0) {
-log.error(tree.pos(), "native.meth.cant.have.body");
+log.error(tree.pos(), Errors.NativeMethCantHaveBody);
 } else {
 // Add an implicit super() call unless an explicit call to
 // super(...) or this(...) is given
 // or we are compiling class java.lang.Object.
 if (tree.name == names.init && owner.type != syms.objectType) {
 // enum constructors are not allowed to call super
 // directly, so make sure there aren't any super calls
 // in enum constructors, except in the compiler
 // generated one.
 log.error(tree.body.stats.head.pos(),
-"call.to.super.not.allowed.in.enum.ctor",
+Errors.CallToSuperNotAllowedInEnumCtor(env.enclClass.sym));
-env.enclClass.sym);
 }
 }
 // Attribute all type annotations in the body
 annotate.queueScanTreeAndTypeAnnotate(tree.body, localEnv, m, null);
 if (elemtype == null) {
 // or perhaps expr implements Iterable<T>?
 Type base = types.asSuper(exprType, syms.iterableType.tsym);
 if (base == null) {
 log.error(tree.expr.pos(),
-"foreach.not.applicable.to.type",
+Errors.ForeachNotApplicableToType(exprType,
-exprType,
+Fragments.TypeReqArrayOrIterable));
-diags.fragment("type.req.array.or.iterable"));
 elemtype = types.createErrorType(exprType);
 } else {
 List<Type> iterableParams = base.allparams();
 elemtype = iterableParams.isEmpty()
 ? syms.objectType
 // Check that label is not used in an enclosing statement
 Env<AttrContext> env1 = env;
 while (env1 != null && !env1.tree.hasTag(CLASSDEF)) {
 if (env1.tree.hasTag(LABELLED) &&
 ((JCLabeledStatement) env1.tree).label == tree.label) {
-log.error(tree.pos(), "label.already.in.use",
+log.error(tree.pos(),
-tree.label);
+Errors.LabelAlreadyInUse(tree.label));
 break;
 }
 env1 = env1.next;
 }
 try {
 boolean enumSwitch = (seltype.tsym.flags() & Flags.ENUM) != 0;
 boolean stringSwitch = types.isSameType(seltype, syms.stringType);
 if (stringSwitch && !allowStringsInSwitch) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, tree.selector.pos(), "string.switch.not.supported.in.source", sourceName);
+log.error(DiagnosticFlag.SOURCE_LEVEL, tree.selector.pos(), Errors.StringSwitchNotSupportedInSource(sourceName));
 }
 if (!enumSwitch && !stringSwitch)
 seltype = chk.checkType(tree.selector.pos(), seltype, syms.intType);
 // Attribute all cases and
 JCCase c = l.head;
 if (c.pat != null) {
 if (enumSwitch) {
 Symbol sym = enumConstant(c.pat, seltype);
 if (sym == null) {
-log.error(c.pat.pos(), "enum.label.must.be.unqualified.enum");
+log.error(c.pat.pos(), Errors.EnumLabelMustBeUnqualifiedEnum);
 } else if (!labels.add(sym)) {
-log.error(c.pos(), "duplicate.case.label");
+log.error(c.pos(), Errors.DuplicateCaseLabel);
 }
 } else {
 Type pattype = attribExpr(c.pat, switchEnv, seltype);
 if (!pattype.hasTag(ERROR)) {
 if (pattype.constValue() == null) {
 log.error(c.pat.pos(),
 (stringSwitch ? "string.const.req" : "const.expr.req"));
 } else if (!labels.add(pattype.constValue())) {
-log.error(c.pos(), "duplicate.case.label");
+log.error(c.pos(), Errors.DuplicateCaseLabel);
 }
 }
 }
 } else if (hasDefault) {
-log.error(c.pos(), "duplicate.default.label");
+log.error(c.pos(), Errors.DuplicateDefaultLabel);
 } else {
 hasDefault = true;
 }
 Env<AttrContext> caseEnv =
 switchEnv.dup(c, env.info.dup(switchEnv.info.scope.dup()));
 // Attribute resource declarations
 for (JCTree resource : tree.resources) {
 CheckContext twrContext = new Check.NestedCheckContext(resultInfo.checkContext) {
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
-chk.basicHandler.report(pos, diags.fragment("try.not.applicable.to.type", details));
+chk.basicHandler.report(pos, diags.fragment(Fragments.TryNotApplicableToType(details)));
 }
 };
 ResultInfo twrResult =
 new ResultInfo(KindSelector.VAR,
 syms.autoCloseableType,
 }
 if (close.kind == MTH &&
 close.overrides(syms.autoCloseableClose, resource.tsym, types, true) &&
 chk.isHandled(syms.interruptedExceptionType, types.memberType(resource, close).getThrownTypes()) &&
 env.info.lint.isEnabled(LintCategory.TRY)) {
-log.warning(LintCategory.TRY, pos, "try.resource.throws.interrupted.exc", resource);
+log.warning(LintCategory.TRY, pos, Warnings.TryResourceThrowsInterruptedExc(resource));
 }
 }
 }
 public void visitConditional(JCConditional tree) {
 isBooleanOrNumeric(env, tree)) ?
 PolyKind.STANDALONE : PolyKind.POLY;
 if (tree.polyKind == PolyKind.POLY && resultInfo.pt.hasTag(VOID)) {
 //this means we are returning a poly conditional from void-compatible lambda expression
-resultInfo.checkContext.report(tree, diags.fragment("conditional.target.cant.be.void"));
+resultInfo.checkContext.report(tree, diags.fragment(Fragments.ConditionalTargetCantBeVoid));
 result = tree.type = types.createErrorType(resultInfo.pt);
 return;
 }
 ResultInfo condInfo = tree.polyKind == PolyKind.STANDALONE ?
 //this will use enclosing check context to check compatibility of
 //subexpression against target type; if we are in a method check context,
 //depending on whether boxing is allowed, we could have incompatibilities
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
-enclosingContext.report(pos, diags.fragment("incompatible.type.in.conditional", details));
+enclosingContext.report(pos, diags.fragment(Fragments.IncompatibleTypeInConditional(details)));
 }
 };
 }
 /** Compute the type of a conditional expression, after
 return elsetype.baseType();
 if (types.isSubtype(elsetype, thentype))
 return thentype.baseType();
 if (thentype.hasTag(VOID) || elsetype.hasTag(VOID)) {
-log.error(pos, "neither.conditional.subtype",
+log.error(pos,
-thentype, elsetype);
+Errors.NeitherConditionalSubtype(thentype,
+elsetype));
 return thentype.baseType();
 }
 // both are known to be reference types.  The result is
 // lub(thentype,elsetype). This cannot fail, as it will
 if (tag == CONTINUE) {
 if (!labelled.body.hasTag(DOLOOP) &&
 !labelled.body.hasTag(WHILELOOP) &&
 !labelled.body.hasTag(FORLOOP) &&
 !labelled.body.hasTag(FOREACHLOOP))
-log.error(pos, "not.loop.label", label);
+log.error(pos, Errors.NotLoopLabel(label));
 // Found labelled statement target, now go inwards
 // to next non-labelled tree.
 return TreeInfo.referencedStatement(labelled);
 } else {
 return labelled;
 default:
 }
 env1 = env1.next;
 }
 if (label != null)
-log.error(pos, "undef.label", label);
+log.error(pos, Errors.UndefLabel(label));
 else if (tag == CONTINUE)
-log.error(pos, "cont.outside.loop");
+log.error(pos, Errors.ContOutsideLoop);
 else
-log.error(pos, "break.outside.switch.loop");
+log.error(pos, Errors.BreakOutsideSwitchLoop);
 return null;
 }
 public void visitReturn(JCReturn tree) {
 // Check that there is an enclosing method which is
 // nested within than the enclosing class.
 if (env.info.returnResult == null) {
-log.error(tree.pos(), "ret.outside.meth");
+log.error(tree.pos(), Errors.RetOutsideMeth);
 } else {
 // Attribute return expression, if it exists, and check that
 // it conforms to result type of enclosing method.
 if (tree.expr != null) {
 if (env.info.returnResult.pt.hasTag(VOID)) {
 env.info.returnResult.checkContext.report(tree.expr.pos(),
-diags.fragment("unexpected.ret.val"));
+diags.fragment(Fragments.UnexpectedRetVal));
 }
 attribTree(tree.expr, env, env.info.returnResult);
 } else if (!env.info.returnResult.pt.hasTag(VOID) &&
 !env.info.returnResult.pt.hasTag(NONE)) {
 env.info.returnResult.checkContext.report(tree.pos(),
-diags.fragment("missing.ret.val"));
+diags.fragment(Fragments.MissingRetVal(env.info.returnResult.pt)));
 }
 }
 result = null;
 }
 // Variable `site' points to the class in which the called
 // constructor is defined.
 Type site = env.enclClass.sym.type;
 if (methName == names._super) {
 if (site == syms.objectType) {
-log.error(tree.meth.pos(), "no.superclass", site);
+log.error(tree.meth.pos(), Errors.NoSuperclass(site));
 site = types.createErrorType(syms.objectType);
 } else {
 site = types.supertype(site);
 }
 }
 // of an appropriate implicit qualifier.
 rs.resolveImplicitThis(tree.meth.pos(),
 localEnv, site, true);
 }
 } else if (tree.meth.hasTag(SELECT)) {
-log.error(tree.meth.pos(), "illegal.qual.not.icls",
+log.error(tree.meth.pos(),
-site.tsym);
+Errors.IllegalQualNotIcls(site.tsym));
 }
 // if we're calling a java.lang.Enum constructor,
 // prefix the implicit String and int parameters
 if (site.tsym == syms.enumSym)
 JCBlock body = enclMethod.body;
 if (body.stats.head.hasTag(EXEC) &&
 ((JCExpressionStatement) body.stats.head).expr == tree)
 return true;
 }
-log.error(tree.pos(),"call.must.be.first.stmt.in.ctor",
+log.error(tree.pos(),
-TreeInfo.name(tree.meth));
+Errors.CallMustBeFirstStmtInCtor(TreeInfo.name(tree.meth)));
 return false;
 }
 /** Obtain a method type with given argument types.
 */
 if (annoclazzid != null) {
 annoclazzid.type = clazzid.type;
 }
 if (!clazztype.isErroneous()) {
 if (cdef != null && clazztype.tsym.isInterface()) {
-log.error(tree.encl.pos(), "anon.class.impl.intf.no.qual.for.new");
+log.error(tree.encl.pos(), Errors.AnonClassImplIntfNoQualForNew);
 } else if (clazztype.tsym.isStatic()) {
-log.error(tree.encl.pos(), "qualified.new.of.static.class", clazztype.tsym);
+log.error(tree.encl.pos(), Errors.QualifiedNewOfStaticClass(clazztype.tsym));
 }
 }
 } else if (!clazztype.tsym.isInterface() &&
 clazztype.getEnclosingType().hasTag(CLASS)) {
 // Check for the existence of an apropos outer instance
 // Enums may not be instantiated except implicitly
 if ((clazztype.tsym.flags_field & Flags.ENUM) != 0 &&
 (!env.tree.hasTag(VARDEF) ||
 (((JCVariableDecl) env.tree).mods.flags & Flags.ENUM) == 0 ||
 ((JCVariableDecl) env.tree).init != tree))
-log.error(tree.pos(), "enum.cant.be.instantiated");
+log.error(tree.pos(), Errors.EnumCantBeInstantiated);
 boolean isSpeculativeDiamondInferenceRound = TreeInfo.isDiamond(tree) &&
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 boolean skipNonDiamondPath = false;
 // Check that class is not abstract
 if (cdef == null && !isSpeculativeDiamondInferenceRound && // class body may be nulled out in speculative tree copy
 (clazztype.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
-log.error(tree.pos(), "abstract.cant.be.instantiated",
+log.error(tree.pos(),
-clazztype.tsym);
+Errors.AbstractCantBeInstantiated(clazztype.tsym));
 skipNonDiamondPath = true;
 } else if (cdef != null && clazztype.tsym.isInterface()) {
 // Check that no constructor arguments are given to
 // anonymous classes implementing an interface
 if (!argtypes.isEmpty())
-log.error(tree.args.head.pos(), "anon.class.impl.intf.no.args");
+log.error(tree.args.head.pos(), Errors.AnonClassImplIntfNoArgs);
 if (!typeargtypes.isEmpty())
-log.error(tree.typeargs.head.pos(), "anon.class.impl.intf.no.typeargs");
+log.error(tree.typeargs.head.pos(), Errors.AnonClassImplIntfNoTypeargs);
 // Error recovery: pretend no arguments were supplied.
 argtypes = List.nil();
 typeargtypes = List.nil();
 skipNonDiamondPath = true;
 CheckContext diamondContext(JCNewClass clazz, TypeSymbol tsym, CheckContext checkContext) {
 return new Check.NestedCheckContext(checkContext) {
 @Override
 public void report(DiagnosticPosition _unused, JCDiagnostic details) {
 enclosingContext.report(clazz.clazz,
-diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", tsym), details));
+diags.fragment(Fragments.CantApplyDiamond1(Fragments.Diamond(tsym), details)));
 }
 };
 }
 /** Make an attributed null check tree.
 // this is allowed only if the prototype is an array
 if (pt().hasTag(ARRAY)) {
 elemtype = types.elemtype(pt());
 } else {
 if (!pt().hasTag(ERROR)) {
-log.error(tree.pos(), "illegal.initializer.for.type",
+log.error(tree.pos(),
-pt());
+Errors.IllegalInitializerForType(pt()));
 }
 elemtype = types.createErrorType(pt());
 }
 }
 if (tree.elems != null) {
 attribExprs(tree.elems, localEnv, elemtype);
 owntype = new ArrayType(elemtype, syms.arrayClass);
 }
 if (!types.isReifiable(elemtype))
-log.error(tree.pos(), "generic.array.creation");
+log.error(tree.pos(), Errors.GenericArrayCreation);
 result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 /*
 * A lambda expression can only be attributed when a target-type is available.
 @Override
 public void visitLambda(final JCLambda that) {
 if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {
 if (pt().hasTag(NONE)) {
 //lambda only allowed in assignment or method invocation/cast context
-log.error(that.pos(), "unexpected.lambda");
+log.error(that.pos(), Errors.UnexpectedLambda);
 }
 result = that.type = types.createErrorType(pt());
 return;
 }
 //create an environment for attribution of the lambda expression
 setFunctionalInfo(localEnv, that, pt(), lambdaType, currentTarget, resultInfo.checkContext);
 if (lambdaType.hasTag(FORALL)) {
 //lambda expression target desc cannot be a generic method
-resultInfo.checkContext.report(that, diags.fragment("invalid.generic.lambda.target",
+Fragment msg = Fragments.InvalidGenericLambdaTarget(lambdaType,
-lambdaType, kindName(currentTarget.tsym), currentTarget.tsym));
+kindName(currentTarget.tsym),
+currentTarget.tsym);
+resultInfo.checkContext.report(that, diags.fragment(msg));
 result = that.type = types.createErrorType(pt());
 return;
 }
 if (that.paramKind == JCLambda.ParameterKind.IMPLICIT) {
 //attribute lambda parameters
 attribStats(that.params, localEnv);
 if (arityMismatch) {
-resultInfo.checkContext.report(that, diags.fragment("incompatible.arg.types.in.lambda"));
+resultInfo.checkContext.report(that, diags.fragment(Fragments.IncompatibleArgTypesInLambda));
 result = that.type = types.createErrorType(currentTarget);
 return;
 }
 }
 currentTarget = Type.recoveryType;
 lambdaType = fallbackDescriptorType(that);
 }
 if (that.hasTag(LAMBDA) && lambdaType.hasTag(FORALL)) {
 //lambda expression target desc cannot be a generic method
-resultInfo.checkContext.report(that, diags.fragment("invalid.generic.lambda.target",
+Fragment msg = Fragments.InvalidGenericLambdaTarget(lambdaType,
-lambdaType, kindName(currentTarget.tsym), currentTarget.tsym));
+kindName(currentTarget.tsym),
+currentTarget.tsym);
+resultInfo.checkContext.report(that, diags.fragment(msg));
 currentTarget = types.createErrorType(pt());
 }
 return new TargetInfo(currentTarget, lambdaType);
 }
 notionalIntf.tsym.flags_field |= INTERFACE;
 return notionalIntf.tsym;
 }
 private void reportIntersectionError(DiagnosticPosition pos, String key, Object... args) {
-resultInfo.checkContext.report(pos, diags.fragment("bad.intersection.target.for.functional.expr",
+resultInfo.checkContext.report(pos,
-diags.fragment(key, args)));
+diags.fragment(Fragments.BadIntersectionTargetForFunctionalExpr(diags.fragment(key, args))));
 }
 };
 private Type fallbackDescriptorType(JCExpression tree) {
 switch (tree.getTag()) {
 return chk.basicHandler.compatible(inferenceContext().asUndetVar(found), inferenceContext().asUndetVar(req), warn);
 }
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
-enclosingContext.report(pos, diags.fragment("incompatible.ret.type.in.lambda", details));
+enclosingContext.report(pos, diags.fragment(Fragments.IncompatibleRetTypeInLambda(details)));
 }
 }
 class ExpressionLambdaReturnContext extends FunctionalReturnContext {
 //values, we must ensure that void/value compatibility is correct;
 //this amounts at checking that, if a lambda body can complete normally,
 //the descriptor's return type must be void
 if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
 !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
-checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
+Fragment msg =
-diags.fragment("missing.ret.val", returnType)));
+Fragments.IncompatibleRetTypeInLambda(Fragments.MissingRetVal(returnType));
+checkContext.report(tree,
+diags.fragment(msg));
 }
 List<Type> argTypes = checkContext.inferenceContext().asUndetVars(descriptor.getParameterTypes());
 if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
-checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
+checkContext.report(tree, diags.fragment(Fragments.IncompatibleArgTypesInLambda));
 }
 }
 /* Map to hold 'fake' clinit methods. If a lambda is used to initialize a
 * static field and that lambda has type annotations, these annotations will
 @Override
 public void visitReference(final JCMemberReference that) {
 if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {
 if (pt().hasTag(NONE)) {
 //method reference only allowed in assignment or method invocation/cast context
-log.error(that.pos(), "unexpected.mref");
+log.error(that.pos(), Errors.UnexpectedMref);
 }
 result = that.type = types.createErrorType(pt());
 return;
 }
 final Env<AttrContext> localEnv = env.dup(that);
 if (that.getMode() == JCMemberReference.ReferenceMode.NEW) {
 exprType = chk.checkConstructorRefType(that.expr, exprType);
 if (!exprType.isErroneous() &&
 exprType.isRaw() &&
 that.typeargs != null) {
-log.error(that.expr.pos(), "invalid.mref", Kinds.kindName(that.getMode()),
+log.error(that.expr.pos(),
-diags.fragment("mref.infer.and.explicit.params"));
+Errors.InvalidMref(Kinds.kindName(that.getMode()),
+Fragments.MrefInferAndExplicitParams));
 exprType = types.createErrorType(exprType);
 }
 }
 if (exprType.isErroneous()) {
 }
 if (that.sym.isStatic() && TreeInfo.isStaticSelector(that.expr, names) &&
 exprType.getTypeArguments().nonEmpty()) {
 //static ref with class type-args
-log.error(that.expr.pos(), "invalid.mref", Kinds.kindName(that.getMode()),
+log.error(that.expr.pos(),
-diags.fragment("static.mref.with.targs"));
+Errors.InvalidMref(Kinds.kindName(that.getMode()),
+Fragments.StaticMrefWithTargs));
 result = that.type = types.createErrorType(currentTarget);
 return;
 }
 if (!refSym.isStatic() && that.kind == JCMemberReference.ReferenceKind.SUPER) {
 incompatibleReturnType = null;
 }
 }
 if (incompatibleReturnType != null) {
-checkContext.report(tree, diags.fragment("incompatible.ret.type.in.mref",
+Fragment msg =
-diags.fragment("inconvertible.types", resType, descriptor.getReturnType())));
+Fragments.IncompatibleRetTypeInMref(Fragments.InconvertibleTypes(resType, descriptor.getReturnType()));
+checkContext.report(tree, diags.fragment(msg));
 } else {
 if (inferenceContext.free(refType)) {
 // we need to wait for inference to finish and then replace inference vars in the referent type
 inferenceContext.addFreeTypeListener(List.of(refType),
 instantiatedContext -> {
 }
 if (!speculativeAttr) {
 List<Type> thrownTypes = inferenceContext.asUndetVars(descriptor.getThrownTypes());
 if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
-log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
+log.error(tree, Errors.IncompatibleThrownTypesInMref(refType.getThrownTypes()));
 }
 //18.2.5: "In addition, for all j (1 <= j <= n), the constraint reduces to the bound throws Ej"
 thrownTypes.stream()
 .filter(t -> t.hasTag(UNDETVAR))
 .forEach(t -> ((UndetVar)t).setThrow());
 public void visitParens(JCParens tree) {
 Type owntype = attribTree(tree.expr, env, resultInfo);
 result = check(tree, owntype, pkind(), resultInfo);
 Symbol sym = TreeInfo.symbol(tree);
 if (sym != null && sym.kind.matches(KindSelector.TYP_PCK))
-log.error(tree.pos(), "illegal.start.of.type");
+log.error(tree.pos(), Errors.IllegalStartOfType);
 }
 public void visitAssign(JCAssign tree) {
 Type owntype = attribTree(tree.lhs, env.dup(tree), varAssignmentInfo);
 Type capturedType = capture(owntype);
 // Check that argument types of a reference ==, != are
 // castable to each other, (JLS 15.21).  Note: unboxing
 // comparisons will not have an acmp* opc at this point.
 if ((opc == ByteCodes.if_acmpeq || opc == ByteCodes.if_acmpne)) {
 if (!types.isCastable(left, right, new Warner(tree.pos()))) {
-log.error(tree.pos(), "incomparable.types", left, right);
+log.error(tree.pos(), Errors.IncomparableTypes(left, right));
 }
 }
 chk.checkDivZero(tree.rhs.pos(), operator, right);
 }
 Type clazztype = attribType(tree.clazz, env);
 if (!clazztype.hasTag(TYPEVAR)) {
 clazztype = chk.checkClassOrArrayType(tree.clazz.pos(), clazztype);
 }
 if (!clazztype.isErroneous() && !types.isReifiable(clazztype)) {
-log.error(tree.clazz.pos(), "illegal.generic.type.for.instof");
+log.error(tree.clazz.pos(), Errors.IllegalGenericTypeForInstof);
 clazztype = types.createErrorType(clazztype);
 }
 chk.validate(tree.clazz, env, false);
 chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
 result = check(tree, syms.booleanType, KindSelector.VAL, resultInfo);
 Type atype = attribExpr(tree.indexed, env);
 attribExpr(tree.index, env, syms.intType);
 if (types.isArray(atype))
 owntype = types.elemtype(atype);
 else if (!atype.hasTag(ERROR))
-log.error(tree.pos(), "array.req.but.found", atype);
+log.error(tree.pos(), Errors.ArrayReqButFound(atype));
 if (!pkind().contains(KindSelector.VAL))
 owntype = capture(owntype);
 result = check(tree, owntype, KindSelector.VAR, resultInfo);
 }
 if (skind == KindSelector.TYP) {
 Type elt = site;
 while (elt.hasTag(ARRAY))
 elt = ((ArrayType)elt).elemtype;
 if (elt.hasTag(TYPEVAR)) {
-log.error(tree.pos(), "type.var.cant.be.deref");
+log.error(tree.pos(), Errors.TypeVarCantBeDeref);
 result = tree.type = types.createErrorType(tree.name, site.tsym, site);
 tree.sym = tree.type.tsym;
 return ;
 }
 }
 // Determine the symbol represented by the selection.
 env.info.pendingResolutionPhase = null;
 Symbol sym = selectSym(tree, sitesym, site, env, resultInfo);
 if (sym.kind == VAR && sym.name != names._super && env.info.defaultSuperCallSite != null) {
-log.error(tree.selected.pos(), "not.encl.class", site.tsym);
+log.error(tree.selected.pos(), Errors.NotEnclClass(site.tsym));
 sym = syms.errSymbol;
 }
 if (sym.exists() && !isType(sym) && pkind().contains(KindSelector.TYP_PCK)) {
 site = capture(site);
 sym = selectSym(tree, sitesym, site, env, resultInfo);
 ((VarSymbol)sitesym).isResourceVariable() &&
 sym.kind == MTH &&
 sym.name.equals(names.close) &&
 sym.overrides(syms.autoCloseableClose, sitesym.type.tsym, types, true) &&
 env.info.lint.isEnabled(LintCategory.TRY)) {
-log.warning(LintCategory.TRY, tree, "try.explicit.close.call");
+log.warning(LintCategory.TRY, tree, Warnings.TryExplicitCloseCall);
 }
 // Disallow selecting a type from an expression
 if (isType(sym) && (sitesym == null || !sitesym.kind.matches(KindSelector.TYP_PCK))) {
 tree.type = check(tree.selected, pt(),
 tree.pos(), site, sym.name, true);
 }
 }
 if (!allowStaticInterfaceMethods && sitesym.isInterface() &&
 sym.isStatic() && sym.kind == MTH) {
-log.error(DiagnosticFlag.SOURCE_LEVEL, tree.pos(), "static.intf.method.invoke.not.supported.in.source", sourceName);
+log.error(DiagnosticFlag.SOURCE_LEVEL, tree.pos(), Errors.StaticIntfMethodInvokeNotSupportedInSource(sourceName));
 }
 } else if (sym.kind != ERR &&
 (sym.flags() & STATIC) != 0 &&
 sym.name != names._class) {
 // If the qualified item is not a type and the selected item is static, report
 // class B<T> extends A<T.foo> {}
 Symbol sym = (site.getUpperBound() != null)
 ? selectSym(tree, location, capture(site.getUpperBound()), env, resultInfo)
 : null;
 if (sym == null) {
-log.error(pos, "type.var.cant.be.deref");
+log.error(pos, Errors.TypeVarCantBeDeref);
 return syms.errSymbol;
 } else {
 Symbol sym2 = (sym.flags() & Flags.PRIVATE) != 0 ?
 rs.new AccessError(env, site, sym) :
 sym;
 Type arg = types.boxedClass(site).type;
 t = new ClassType(t.getEnclosingType(), List.of(arg), t.tsym);
 return new VarSymbol(
 STATIC | PUBLIC | FINAL, names._class, t, site.tsym);
 } else {
-log.error(pos, "cant.deref", site);
+log.error(pos, Errors.CantDeref(site));
 return syms.errSymbol;
 }
 }
 }
 // If the reference isn't from an initializer, then
 // the reference is OK.
 if (!Resolve.isInitializer(env))
 return;
-log.error(tree.pos(), "illegal.enum.static.ref");
+log.error(tree.pos(), Errors.IllegalEnumStaticRef);
 }
 }
 /** Is the given symbol a static, non-constant field of an Enum?
 *  Note: enum literals should not be regarded as such
 List<MethodSymbol> icand_sup =
 types.interfaceCandidates(sup, (MethodSymbol)sym);
 if (icand_sup.nonEmpty() &&
 icand_sup.head != sym &&
 icand_sup.head.overrides(sym, icand_sup.head.enclClass(), types, true)) {
-log.error(env.tree.pos(), "illegal.default.super.call", env.info.defaultSuperCallSite,
+log.error(env.tree.pos(),
-diags.fragment("overridden.default", sym, sup));
+Errors.IllegalDefaultSuperCall(env.info.defaultSuperCallSite, Fragments.OverriddenDefault(sym, sup)));
 break;
 }
 }
 env.info.defaultSuperCallSite = null;
 }
 if (sym.isStatic() && site.isInterface() && env.tree.hasTag(APPLY)) {
 JCMethodInvocation app = (JCMethodInvocation)env.tree;
 if (app.meth.hasTag(SELECT) &&
 !TreeInfo.isStaticSelector(((JCFieldAccess)app.meth).selected, names)) {
-log.error(env.tree.pos(), "illegal.static.intf.meth.call", site);
+log.error(env.tree.pos(), Errors.IllegalStaticIntfMethCall(site));
 }
 }
 // Compute the identifier's instantiated type.
 // For methods, we need to compute the instance type by
 }
 owntype = new ClassType(clazzOuter, actuals, clazztype.tsym,
 clazztype.getMetadata());
 } else {
 if (formals.length() != 0) {
-log.error(tree.pos(), "wrong.number.type.args",
+log.error(tree.pos(),
-Integer.toString(formals.length()));
+Errors.WrongNumberTypeArgs(Integer.toString(formals.length())));
 } else {
-log.error(tree.pos(), "type.doesnt.take.params", clazztype.tsym);
+log.error(tree.pos(), Errors.TypeDoesntTakeParams(clazztype.tsym));
 }
 owntype = types.createErrorType(tree.type);
 }
 }
 result = check(tree, owntype, KindSelector.TYP, resultInfo);
 boolean sup = types.isSubtype(t, ctype);
 if (sub || sup) {
 //assume 'a' <: 'b'
 Type a = sub ? ctype : t;
 Type b = sub ? t : ctype;
-log.error(typeTree.pos(), "multicatch.types.must.be.disjoint", a, b);
+log.error(typeTree.pos(), Errors.MulticatchTypesMustBeDisjoint(a, b));
 }
 }
 }
 multicatchTypes.append(ctype);
 if (all_multicatchTypes != null)
 }
 else if (bounds.head.type.hasTag(TYPEVAR)) {
 // if first bound was a typevar, do not accept further bounds.
 if (bounds.tail.nonEmpty()) {
 log.error(bounds.tail.head.pos(),
-"type.var.may.not.be.followed.by.other.bounds");
+Errors.TypeVarMayNotBeFollowedByOtherBounds);
 return bounds.head.type;
 }
 } else {
 // if first bound was a class or interface, accept only interfaces
 // as further bounds.
 deferredLintHandler.flush(env.tree);
 env.info.returnResult = null;
 // java.lang.Enum may not be subclassed by a non-enum
 if (st.tsym == syms.enumSym &&
 ((c.flags_field & (Flags.ENUM|Flags.COMPOUND)) == 0))
-log.error(env.tree.pos(), "enum.no.subclassing");
+log.error(env.tree.pos(), Errors.EnumNoSubclassing);
 // Enums may not be extended by source-level classes
 if (st.tsym != null &&
 ((st.tsym.flags_field & Flags.ENUM) != 0) &&
 ((c.flags_field & (Flags.ENUM | Flags.COMPOUND)) == 0)) {
-log.error(env.tree.pos(), "enum.types.not.extensible");
+log.error(env.tree.pos(), Errors.EnumTypesNotExtensible);
 }
 if (isSerializable(c.type)) {
 env.info.isSerializable = true;
 }
 }
 if ((c.flags() & ANNOTATION) != 0) {
 if (tree.implementing.nonEmpty())
 log.error(tree.implementing.head.pos(),
-"cant.extend.intf.annotation");
+Errors.CantExtendIntfAnnotation);
-if (tree.typarams.nonEmpty())
+if (tree.typarams.nonEmpty()) {
 log.error(tree.typarams.head.pos(),
-"intf.annotation.cant.have.type.params");
+Errors.IntfAnnotationCantHaveTypeParams(c));
+}
 // If this annotation type has a @Repeatable, validate
 Attribute.Compound repeatable = c.getAnnotationTypeMetadata().getRepeatable();
 // If this annotation type has a @Repeatable, validate
 if (repeatable != null) {
 Assert.checkNonNull(env.info.scope.findFirst(l.head.name));
 }
 // Check that a generic class doesn't extend Throwable
 if (!c.type.allparams().isEmpty() && types.isSubtype(c.type, syms.throwableType))
-log.error(tree.extending.pos(), "generic.throwable");
+log.error(tree.extending.pos(), Errors.GenericThrowable);
 // Check that all methods which implement some
 // method conform to the method they implement.
 chk.checkImplementations(tree);
 Symbol sym = null;
 if (l.head.hasTag(VARDEF)) sym = ((JCVariableDecl) l.head).sym;
 if (sym == null ||
 sym.kind != VAR ||
 ((VarSymbol) sym).getConstValue() == null)
-log.error(l.head.pos(), "icls.cant.have.static.decl", c);
+log.error(l.head.pos(), Errors.IclsCantHaveStaticDecl(c));
 }
 }
 // Check for cycles among non-initial constructors.
 chk.checkCyclicConstructors(tree);
 }
 }
 if (svuid == null) {
 log.warning(LintCategory.SERIAL,
-tree.pos(), "missing.SVUID", c);
+tree.pos(), Warnings.MissingSVUID(c));
 return;
 }
 // check that it is static final
 if ((svuid.flags() & (STATIC | FINAL)) !=
 (STATIC | FINAL))
 log.warning(LintCategory.SERIAL,
-TreeInfo.diagnosticPositionFor(svuid, tree), "improper.SVUID", c);
+TreeInfo.diagnosticPositionFor(svuid, tree), Warnings.ImproperSVUID(c));
 // check that it is long
 else if (!svuid.type.hasTag(LONG))
 log.warning(LintCategory.SERIAL,
-TreeInfo.diagnosticPositionFor(svuid, tree), "long.SVUID", c);
+TreeInfo.diagnosticPositionFor(svuid, tree), Warnings.LongSVUID(c));
 // check constant
 else if (svuid.getConstValue() == null)
 log.warning(LintCategory.SERIAL,
-TreeInfo.diagnosticPositionFor(svuid, tree), "constant.SVUID", c);
+TreeInfo.diagnosticPositionFor(svuid, tree), Warnings.ConstantSVUID(c));
 }
 private Type capture(Type type) {
 return types.capture(type);
 }
 }
 } else if (enclTr.hasTag(ANNOTATED_TYPE)) {
 JCAnnotatedType at = (JCTree.JCAnnotatedType) enclTr;
 if (enclTy == null || enclTy.hasTag(NONE)) {
 if (at.getAnnotations().size() == 1) {
-log.error(at.underlyingType.pos(), "cant.type.annotate.scoping.1", at.getAnnotations().head.attribute);
+log.error(at.underlyingType.pos(), Errors.CantTypeAnnotateScoping1(at.getAnnotations().head.attribute));
 } else {
 ListBuffer<Attribute.Compound> comps = new ListBuffer<>();
 for (JCAnnotation an : at.getAnnotations()) {
 comps.add(an.attribute);
 }
-log.error(at.underlyingType.pos(), "cant.type.annotate.scoping", comps.toList());
+log.error(at.underlyingType.pos(), Errors.CantTypeAnnotateScoping(comps.toList()));
 }
 repeat = false;
 }
 enclTr = at.underlyingType;
 // enclTy doesn't need to be changed

changeset 45504	ea7475564d07
parent 44571	1140b8dad6bb
child 45605	8d019eee3515