jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Annotate.java

-:9f42a06a49c0
+:df694c775e8a
 /*
-* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 new Attribute.Array(arrayOfOrigAnnoType, repeated));
 annoTree = m.Annotation(new Attribute.Compound(targetContainerType,
 List.of(p)));
 if (!chk.annotationApplicable(annoTree, on))
-log.error(annoTree.pos(), "invalid.containedby.annotation.incompatible.target", targetContainerType, origAnnoType);
+log.error(annoTree.pos(), "invalid.repeatable.annotation.incompatible.target", targetContainerType, origAnnoType);
 if (!chk.validateAnnotationDeferErrors(annoTree))
 log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType);
 Attribute.Compound c = enterAnnotation(annoTree,
 DiagnosticPosition pos)
 {
 Type origAnnoType = currentAnno.type;
 TypeSymbol origAnnoDecl = origAnnoType.tsym;
-// Fetch the ContainedBy annotation from the current
+// Fetch the Repeatable annotation from the current
 // annotation's declaration, or null if it has none
-Attribute.Compound ca = origAnnoDecl.attribute(syms.containedByType.tsym);
+Attribute.Compound ca = origAnnoDecl.attribute(syms.repeatableType.tsym);
-if (ca == null) { // has no ContainedBy annotation
+if (ca == null) { // has no Repeatable annotation
-log.error(pos, "duplicate.annotation.missing.container", origAnnoType, syms.containedByType);
+log.error(pos, "duplicate.annotation.missing.container", origAnnoType, syms.repeatableType);
 return null;
 }
 return filterSame(extractContainingType(ca, pos, origAnnoDecl),
 origAnnoType);
 /** Extract the actual Type to be used for a containing annotation. */
 private Type extractContainingType(Attribute.Compound ca,
 DiagnosticPosition pos,
 TypeSymbol annoDecl)
 {
-// The next three checks check that the ContainedBy annotation
+// The next three checks check that the Repeatable annotation
 // on the declaration of the annotation type that is repeating is
 // valid.
-// ContainedBy must have at least one element
+// Repeatable must have at least one element
 if (ca.values.isEmpty()) {
-log.error(pos, "invalid.containedby.annotation", annoDecl);
+log.error(pos, "invalid.repeatable.annotation", annoDecl);
 return null;
 }
 Pair<MethodSymbol,Attribute> p = ca.values.head;
 Name name = p.fst.name;
 if (name != names.value) { // should contain only one element, named "value"
-log.error(pos, "invalid.containedby.annotation", annoDecl);
+log.error(pos, "invalid.repeatable.annotation", annoDecl);
 return null;
 }
 if (!(p.snd instanceof Attribute.Class)) { // check that the value of "value" is an Attribute.Class
-log.error(pos, "invalid.containedby.annotation", annoDecl);
+log.error(pos, "invalid.repeatable.annotation", annoDecl);
 return null;
 }
 return ((Attribute.Class)p.snd).getValue();
 }
 error = true;
 }
 }
 if (error) {
 log.error(pos,
-"invalid.containedby.annotation.multiple.values",
+"invalid.repeatable.annotation.multiple.values",
 targetContainerType,
 nr_value_elems);
 return null;
 } else if (nr_value_elems == 0) {
 log.error(pos,
-"invalid.containedby.annotation.no.value",
+"invalid.repeatable.annotation.no.value",
 targetContainerType);
 return null;
 }
 // validate that the 'value' element is a method
 // probably "impossible" to fail this
 if (containerValueSymbol.kind != Kinds.MTH) {
 log.error(pos,
-"invalid.containedby.annotation.invalid.value",
+"invalid.repeatable.annotation.invalid.value",
 targetContainerType);
 fatalError = true;
 }
 // validate that the 'value' element has the correct return type
 Type valueRetType = containerValueSymbol.type.getReturnType();
 Type expectedType = types.makeArrayType(originalAnnoType);
 if (!(types.isArray(valueRetType) &&
 types.isSameType(expectedType, valueRetType))) {
 log.error(pos,
-"invalid.containedby.annotation.value.return",
+"invalid.repeatable.annotation.value.return",
 targetContainerType,
 valueRetType,
 expectedType);
 fatalError = true;
 }
 if (error) {
 fatalError = true;
 }
-// Explicitly no check for/validity of @ContainerFor. That is
+// The conditions for a valid containing annotation are made
-// done on declaration of the container, and at reflect time.
-// The rest of the conditions for a valid containing annotation are made
 // in Check.validateRepeatedAnnotaton();
 return fatalError ? null : containerValueSymbol;
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Annotate.java

src/share/classes/com/sun/tools/javac/comp/Annotate.java