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

-:5c956be64b9e
+:71f35e4b93a5
 */
 package com.sun.tools.javac.comp;
 import java.util.Map;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.*;
 *********************************************************************/
 private int enterCount = 0;
 ListBuffer<Annotator> q = new ListBuffer<Annotator>();
+ListBuffer<Annotator> typesQ = new ListBuffer<Annotator>();
 ListBuffer<Annotator> repeatedQ = new ListBuffer<Annotator>();
+ListBuffer<Annotator> afterRepeatedQ = new ListBuffer<Annotator>();
+public void earlier(Annotator a) {
+q.prepend(a);
+}
 public void normal(Annotator a) {
 q.append(a);
 }
-public void earlier(Annotator a) {
+public void typeAnnotation(Annotator a) {
-q.prepend(a);
+typesQ.append(a);
 }
 public void repeated(Annotator a) {
 repeatedQ.append(a);
+}
+public void afterRepeated(Annotator a) {
+afterRepeatedQ.append(a);
 }
 /** Called when the Enter phase starts. */
 public void enterStart() {
 enterCount++;
 public void flush() {
 if (enterCount != 0) return;
 enterCount++;
 try {
-while (q.nonEmpty())
+while (q.nonEmpty()) {
 q.next().enterAnnotation();
+}
+while (typesQ.nonEmpty()) {
+typesQ.next().enterAnnotation();
+}
 while (repeatedQ.nonEmpty()) {
 repeatedQ.next().enterAnnotation();
+}
+while (afterRepeatedQ.nonEmpty()) {
+afterRepeatedQ.next().enterAnnotation();
 }
 } finally {
 enterCount--;
 }
 }
 /**
 * This context contains all the information needed to synthesize new
 * annotations trees by the completer for repeating annotations.
 */
-public class AnnotateRepeatedContext {
+public class AnnotateRepeatedContext<T extends Attribute.Compound> {
 public final Env<AttrContext> env;
-public final Map<Symbol.TypeSymbol, ListBuffer<Attribute.Compound>> annotated;
+public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;
-public final Map<Attribute.Compound, JCDiagnostic.DiagnosticPosition> pos;
+public final Map<T, JCDiagnostic.DiagnosticPosition> pos;
 public final Log log;
+public final boolean isTypeCompound;
 public AnnotateRepeatedContext(Env<AttrContext> env,
-Map<Symbol.TypeSymbol, ListBuffer<Attribute.Compound>> annotated,
+Map<Symbol.TypeSymbol, ListBuffer<T>> annotated,
-Map<Attribute.Compound, JCDiagnostic.DiagnosticPosition> pos,
+Map<T, JCDiagnostic.DiagnosticPosition> pos,
-Log log) {
+Log log,
+boolean isTypeCompound) {
 Assert.checkNonNull(env);
 Assert.checkNonNull(annotated);
 Assert.checkNonNull(pos);
 Assert.checkNonNull(log);
 this.env = env;
 this.annotated = annotated;
 this.pos = pos;
 this.log = log;
+this.isTypeCompound = isTypeCompound;
 }
 /**
 * Process a list of repeating annotations returning a new
 * Attribute.Compound that is the attribute for the synthesized tree
 * for the container.
 *
 * @param repeatingAnnotations a List of repeating annotations
 * @return a new Attribute.Compound that is the container for the repeatingAnnotations
 */
-public Attribute.Compound processRepeatedAnnotations(List<Attribute.Compound> repeatingAnnotations, Symbol sym) {
+public T processRepeatedAnnotations(List<T> repeatingAnnotations, Symbol sym) {
 return Annotate.this.processRepeatedAnnotations(repeatingAnnotations, this, sym);
 }
 /**
 * Queue the Annotator a on the repeating annotations queue of the
 if (!method.type.isErroneous())
 buf.append(new Pair<MethodSymbol,Attribute>
 ((MethodSymbol)method, value));
 t.type = result;
 }
-return new Attribute.Compound(a.type, buf.toList());
+// TODO: this should be a TypeCompound if "a" is a JCTypeAnnotation.
+// However, how do we find the correct position?
+Attribute.Compound ac = new Attribute.Compound(a.type, buf.toList());
+// TODO: is this something we want? Who would use it?
+// a.attribute = ac;
+return ac;
 }
 Attribute enterAttributeValue(Type expected,
 JCExpression tree,
 Env<AttrContext> env) {
 if (!expected.isErroneous())
 log.error(tree.pos(), "annotation.value.not.allowable.type");
 return new Attribute.Error(attr.attribExpr(tree, env, expected));
 }
+Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,
+Type expected,
+Env<AttrContext> env) {
+Attribute.Compound c = enterAnnotation(a, expected, env);
+Attribute.TypeCompound tc = new Attribute.TypeCompound(c.type, c.values, new TypeAnnotationPosition());
+a.attribute = tc;
+return tc;
+}
 /* *********************************
 * Support for repeating annotations
 ***********************************/
 /* Process repeated annotations. This method returns the
 * synthesized container annotation or null IFF all repeating
 * annotation are invalid.  This method reports errors/warnings.
 */
-private Attribute.Compound processRepeatedAnnotations(List<Attribute.Compound> annotations,
+private <T extends Attribute.Compound> T processRepeatedAnnotations(List<T> annotations,
-AnnotateRepeatedContext ctx,
+AnnotateRepeatedContext<T> ctx,
 Symbol on) {
-Attribute.Compound firstOccurrence = annotations.head;
+T firstOccurrence = annotations.head;
 List<Attribute> repeated = List.nil();
 Type origAnnoType = null;
 Type arrayOfOrigAnnoType = null;
 Type targetContainerType = null;
 MethodSymbol containerValueSymbol = null;
 Assert.check(!annotations.isEmpty() &&
 !annotations.tail.isEmpty()); // i.e. size() > 1
-for (List<Attribute.Compound> al = annotations;
+for (List<T> al = annotations;
 !al.isEmpty();
 al = al.tail)
 {
-Attribute.Compound currentAnno = al.head;
+T currentAnno = al.head;
 origAnnoType = currentAnno.type;
 if (arrayOfOrigAnnoType == null) {
 arrayOfOrigAnnoType = types.makeArrayType(origAnnoType);
 }
 Type currentContainerType = getContainingType(currentAnno, ctx.pos.get(currentAnno));
 if (currentContainerType == null) {
 continue;
 }
 repeated = repeated.prepend(currentAnno);
 }
 if (!repeated.isEmpty()) {
 repeated = repeated.reverse();
-JCAnnotation annoTree;
 TreeMaker m = make.at(ctx.pos.get(firstOccurrence));
 Pair<MethodSymbol, Attribute> p =
 new Pair<MethodSymbol, Attribute>(containerValueSymbol,
 new Attribute.Array(arrayOfOrigAnnoType, repeated));
-annoTree = m.Annotation(new Attribute.Compound(targetContainerType,
+if (ctx.isTypeCompound) {
-List.of(p)));
+/* TODO: the following code would be cleaner:
+Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
-if (!chk.annotationApplicable(annoTree, on))
+((Attribute.TypeCompound)annotations.head).position);
-log.error(annoTree.pos(), "invalid.repeatable.annotation.incompatible.target", targetContainerType, origAnnoType);
+JCTypeAnnotation annoTree = m.TypeAnnotation(at);
+at = enterTypeAnnotation(annoTree, targetContainerType, ctx.env);
-if (!chk.validateAnnotationDeferErrors(annoTree))
+*/
-log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType);
+// However, we directly construct the TypeCompound to keep the
+// direct relation to the contained TypeCompounds.
-Attribute.Compound c = enterAnnotation(annoTree,
+Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
-targetContainerType,
+((Attribute.TypeCompound)annotations.head).position);
-ctx.env);
-c.setSynthesized(true);
+// TODO: annotation applicability checks from below?
-return c;
+at.setSynthesized(true);
+@SuppressWarnings("unchecked")
+T x = (T) at;
+return x;
+} else {
+Attribute.Compound c = new Attribute.Compound(targetContainerType, List.of(p));
+JCAnnotation annoTree = m.Annotation(c);
+if (!chk.annotationApplicable(annoTree, on))
+log.error(annoTree.pos(), "invalid.repeatable.annotation.incompatible.target", targetContainerType, origAnnoType);
+if (!chk.validateAnnotationDeferErrors(annoTree))
+log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType);
+c = enterAnnotation(annoTree, targetContainerType, ctx.env);
+c.setSynthesized(true);
+@SuppressWarnings("unchecked")
+T x = (T) c;
+return x;
+}
 } else {
 return null; // errors should have been reported elsewhere
 }
 }

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