diff -r d23ae2d67a5d -r ea7475564d07 langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java --- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java Wed Jun 14 20:05:01 2017 +0000 +++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java Thu Jun 15 13:44:42 2017 +0200 @@ -254,7 +254,7 @@ Lint prevLint = deferPos != null ? null : chk.setLint(lint); try { if (s.hasAnnotations() && annotations.nonEmpty()) - log.error(annotations.head.pos, "already.annotated", Kinds.kindName(s), s); + log.error(annotations.head.pos, Errors.AlreadyAnnotated(Kinds.kindName(s), s)); Assert.checkNonNull(s, "Symbol argument to actualEnterAnnotations is null"); @@ -342,7 +342,7 @@ if (annotated.containsKey(a.type.tsym)) { if (!allowRepeatedAnnos) { - log.error(DiagnosticFlag.SOURCE_LEVEL, a.pos(), "repeatable.annotations.not.supported.in.source", sourceName); + log.error(DiagnosticFlag.SOURCE_LEVEL, a.pos(), Errors.RepeatableAnnotationsNotSupportedInSource(sourceName)); } ListBuffer l = annotated.get(a.type.tsym); l = l.append(c); @@ -456,8 +456,7 @@ boolean isError = a.type.isErroneous(); if (!a.type.tsym.isAnnotationType() && !isError) { - log.error(a.annotationType.pos(), - "not.annotation.type", a.type.toString()); + log.error(a.annotationType.pos(), Errors.NotAnnotationType(a.type)); isError = true; } @@ -486,13 +485,13 @@ Type thisAnnotationType, boolean badAnnotation, Env env, boolean elidedValue) { if (!nameValuePair.hasTag(ASSIGN)) { - log.error(nameValuePair.pos(), "annotation.value.must.be.name.value"); + log.error(nameValuePair.pos(), Errors.AnnotationValueMustBeNameValue); attributeAnnotationValue(nameValuePair.type = syms.errType, nameValuePair, env); return null; } JCAssign assign = (JCAssign)nameValuePair; if (!assign.lhs.hasTag(IDENT)) { - log.error(nameValuePair.pos(), "annotation.value.must.be.name.value"); + log.error(nameValuePair.pos(), Errors.AnnotationValueMustBeNameValue); attributeAnnotationValue(nameValuePair.type = syms.errType, nameValuePair, env); return null; } @@ -505,7 +504,7 @@ left.sym = method; left.type = method.type; if (method.owner != thisAnnotationType.tsym && !badAnnotation) - log.error(left.pos(), "no.annotation.member", left.name, thisAnnotationType); + log.error(left.pos(), Errors.NoAnnotationMember(left.name, thisAnnotationType)); Type resultType = method.type.getReturnType(); // Compute value part @@ -526,7 +525,7 @@ try { expectedElementType.tsym.complete(); } catch(CompletionFailure e) { - log.error(tree.pos(), "cant.resolve", Kinds.kindName(e.sym), e.sym); + log.error(tree.pos(), Errors.CantResolve(Kinds.kindName(e.sym), e.sym.getQualifiedName(), null, null)); expectedElementType = syms.errType; } @@ -538,10 +537,10 @@ //error recovery if (tree.hasTag(NEWARRAY)) { if (!expectedElementType.isErroneous()) - log.error(tree.pos(), "annotation.value.not.allowable.type"); + log.error(tree.pos(), Errors.AnnotationValueNotAllowableType); JCNewArray na = (JCNewArray)tree; if (na.elemtype != null) { - log.error(na.elemtype.pos(), "new.not.allowed.in.annotation"); + log.error(na.elemtype.pos(), Errors.NewNotAllowedInAnnotation); } for (List l = na.elems; l.nonEmpty(); l=l.tail) { attributeAnnotationValue(syms.errType, @@ -555,7 +554,7 @@ if (tree.hasTag(ANNOTATION)) { return attributeAnnotation((JCAnnotation)tree, expectedElementType, env); } else { - log.error(tree.pos(), "annotation.value.must.be.annotation"); + log.error(tree.pos(), Errors.AnnotationValueMustBeAnnotation); expectedElementType = syms.errType; } } @@ -563,7 +562,7 @@ //error recovery if (tree.hasTag(ANNOTATION)) { if (!expectedElementType.isErroneous()) - log.error(tree.pos(), "annotation.not.valid.for.type", expectedElementType); + log.error(tree.pos(), Errors.AnnotationNotValidForType(expectedElementType)); attributeAnnotation((JCAnnotation)tree, syms.errType, env); return new Attribute.Error(((JCAnnotation)tree).annotationType.type); } @@ -598,7 +597,7 @@ //error recovery: if (!expectedElementType.isErroneous()) - log.error(tree.pos(), "annotation.value.not.allowable.type"); + log.error(tree.pos(), Errors.AnnotationValueNotAllowableType); return new Attribute.Error(attr.attribExpr(tree, env, expectedElementType)); } @@ -609,7 +608,7 @@ TreeInfo.nonstaticSelect(tree) || sym.kind != VAR || (sym.flags() & Flags.ENUM) == 0) { - log.error(tree.pos(), "enum.annotation.must.be.enum.constant"); + log.error(tree.pos(), Errors.EnumAnnotationMustBeEnumConstant); return new Attribute.Error(result.getOriginalType()); } VarSymbol enumerator = (VarSymbol) sym; @@ -640,7 +639,7 @@ if (result.isErroneous()) return new Attribute.Error(result.getOriginalType()); if (result.constValue() == null) { - log.error(tree.pos(), "attribute.value.must.be.constant"); + log.error(tree.pos(), Errors.AttributeValueMustBeConstant); return new Attribute.Error(expectedElementType); } result = cfolder.coerce(result, expectedElementType); @@ -656,7 +655,7 @@ JCNewArray na = (JCNewArray)tree; if (na.elemtype != null) { - log.error(na.elemtype.pos(), "new.not.allowed.in.annotation"); + log.error(na.elemtype.pos(), Errors.NewNotAllowedInAnnotation); } ListBuffer buf = new ListBuffer<>(); for (List l = na.elems; l.nonEmpty(); l=l.tail) { @@ -751,7 +750,7 @@ } if (!repeated.isEmpty() && targetContainerType == null) { - log.error(ctx.pos.get(annotations.head), "duplicate.annotation.invalid.repeated", origAnnoType); + log.error(ctx.pos.get(annotations.head), Errors.DuplicateAnnotationInvalidRepeated(origAnnoType)); return null; } @@ -798,7 +797,7 @@ } if (!chk.validateAnnotationDeferErrors(annoTree)) - log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType); + log.error(annoTree.pos(), Errors.DuplicateAnnotationInvalidRepeated(origAnnoType)); c = attributeAnnotation(annoTree, targetContainerType, ctx.env); c.setSynthesized(true); @@ -827,7 +826,7 @@ Attribute.Compound ca = origAnnoDecl.getAnnotationTypeMetadata().getRepeatable(); if (ca == null) { // has no Repeatable annotation if (reportError) - log.error(pos, "duplicate.annotation.missing.container", origAnnoType, syms.repeatableType); + log.error(pos, Errors.DuplicateAnnotationMissingContainer(origAnnoType)); return null; } @@ -855,17 +854,17 @@ // Repeatable must have at least one element if (ca.values.isEmpty()) { - log.error(pos, "invalid.repeatable.annotation", annoDecl); + log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl)); return null; } Pair p = ca.values.head; Name name = p.fst.name; if (name != names.value) { // should contain only one element, named "value" - log.error(pos, "invalid.repeatable.annotation", annoDecl); + log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl)); return null; } if (!(p.snd instanceof Attribute.Class)) { // check that the value of "value" is an Attribute.Class - log.error(pos, "invalid.repeatable.annotation", annoDecl); + log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl)); return null; } @@ -900,14 +899,12 @@ } if (error) { log.error(pos, - "invalid.repeatable.annotation.multiple.values", - targetContainerType, - nr_value_elems); + Errors.InvalidRepeatableAnnotationMultipleValues(targetContainerType, + nr_value_elems)); return null; } else if (nr_value_elems == 0) { log.error(pos, - "invalid.repeatable.annotation.no.value", - targetContainerType); + Errors.InvalidRepeatableAnnotationNoValue(targetContainerType)); return null; } @@ -915,8 +912,7 @@ // probably "impossible" to fail this if (containerValueSymbol.kind != MTH) { log.error(pos, - "invalid.repeatable.annotation.invalid.value", - targetContainerType); + Errors.InvalidRepeatableAnnotationInvalidValue(targetContainerType)); fatalError = true; } @@ -927,10 +923,9 @@ if (!(types.isArray(valueRetType) && types.isSameType(expectedType, valueRetType))) { log.error(pos, - "invalid.repeatable.annotation.value.return", - targetContainerType, - valueRetType, - expectedType); + Errors.InvalidRepeatableAnnotationValueReturn(targetContainerType, + valueRetType, + expectedType)); fatalError = true; } @@ -951,8 +946,7 @@ ListBuffer manualContainer = ctx.annotated.get(validRepeated.type.tsym); if (manualContainer != null) { log.error(ctx.pos.get(manualContainer.first()), - "invalid.repeatable.annotation.repeated.and.container.present", - manualContainer.first().type.tsym); + Errors.InvalidRepeatableAnnotationRepeatedAndContainerPresent(manualContainer.first().type.tsym)); } }