changeset 23129:6d3b2e246dac

8035766: Execute TypeAnnotate visitor at queue flush time Summary: Moved execution of TypeAnnotate visitor into Worker for type annotations Reviewed-by: jjg
author emc
date Thu, 27 Feb 2014 00:29:22 -0500
parents c91951cf65f0
children 6b9f74a8aeb9
files langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java
diffstat 3 files changed, 72 insertions(+), 75 deletions(-) [+]
line wrap: on
line diff
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Wed Feb 26 18:05:02 2014 -0800
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Thu Feb 27 00:29:22 2014 -0500
@@ -790,44 +790,69 @@
      */
     private void actualEnterTypeAnnotations(final List<JCAnnotation> annotations,
                                             final Env<AttrContext> env,
-                                            final Symbol s) {
+                                            final Symbol s,
+                                            final DiagnosticPosition deferPos) {
         Map<TypeSymbol, ListBuffer<Attribute.TypeCompound>> annotated = new LinkedHashMap<>();
         Map<Attribute.TypeCompound, DiagnosticPosition> pos = new HashMap<>();
 
-        for (List<JCAnnotation> al = annotations; !al.isEmpty(); al = al.tail) {
-            JCAnnotation a = al.head;
-            Attribute.TypeCompound tc =
-                enterTypeAnnotation(a, syms.annotationType, env);
+        JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
+        DiagnosticPosition prevLintPos = null;
 
-            if (tc == null) {
-                continue;
+        if (deferPos != null) {
+            prevLintPos = deferredLintHandler.setPos(deferPos);
+        }
+        try {
+
+            for (List<JCAnnotation> al = annotations; !al.isEmpty(); al = al.tail) {
+                JCAnnotation a = al.head;
+                Attribute.TypeCompound tc =
+                    enterTypeAnnotation(a, syms.annotationType, env);
+
+                if (tc == null) {
+                    continue;
+                }
+
+                if (annotated.containsKey(a.type.tsym)) {
+                    if (!allowRepeatedAnnos) {
+                        log.error(a.pos(), "repeatable.annotations.not.supported.in.source");
+                        allowRepeatedAnnos = true;
+                    }
+                    ListBuffer<Attribute.TypeCompound> l = annotated.get(a.type.tsym);
+                    l = l.append(tc);
+                    annotated.put(a.type.tsym, l);
+                    pos.put(tc, a.pos());
+                } else {
+                    annotated.put(a.type.tsym, ListBuffer.of(tc));
+                    pos.put(tc, a.pos());
+                }
             }
 
-            if (annotated.containsKey(a.type.tsym)) {
-                if (!allowRepeatedAnnos) {
-                    log.error(a.pos(), "repeatable.annotations.not.supported.in.source");
-                    allowRepeatedAnnos = true;
-                }
-                ListBuffer<Attribute.TypeCompound> l = annotated.get(a.type.tsym);
-                l = l.append(tc);
-                annotated.put(a.type.tsym, l);
-                pos.put(tc, a.pos());
-            } else {
-                annotated.put(a.type.tsym, ListBuffer.of(tc));
-                pos.put(tc, a.pos());
+            if (s != null) {
+                s.appendTypeAttributesWithCompletion(
+                    new AnnotateRepeatedContext<>(env, annotated, pos, log, true));
             }
-        }
-
-        if (s != null) {
-            s.appendTypeAttributesWithCompletion(
-                new AnnotateRepeatedContext<>(env, annotated, pos, log, true));
+        } finally {
+            if (prevLintPos != null)
+                deferredLintHandler.setPos(prevLintPos);
+            log.useSource(prev);
         }
     }
 
-    public void typeAnnotate(final JCTree tree, final Env<AttrContext> env, final Symbol sym, DiagnosticPosition deferPos) {
-        if (allowTypeAnnos) {
-            tree.accept(new TypeAnnotate(env, sym, deferPos));
-        }
+    public void annotateTypeLater(final JCTree tree,
+                                  final Env<AttrContext> env,
+                                  final Symbol sym,
+                                  final DiagnosticPosition deferPos) {
+
+        normal(new Annotate.Worker() {
+                @Override
+                public String toString() {
+                    return "type annotate " + tree + " onto " + sym + " in " + sym.owner;
+                }
+                @Override
+                public void run() {
+                    tree.accept(new TypeAnnotate(env, sym, deferPos));
+                }
+            });
     }
 
     /**
@@ -835,64 +860,36 @@
      * annotations. We also need to visit type arguments, etc.
      */
     private class TypeAnnotate extends TreeScanner {
-        private Env<AttrContext> env;
-        private Symbol sym;
+        private final Env<AttrContext> env;
+        private final Symbol sym;
         private DiagnosticPosition deferPos;
 
-        public TypeAnnotate(final Env<AttrContext> env, final Symbol sym, DiagnosticPosition deferPos) {
+        public TypeAnnotate(final Env<AttrContext> env,
+                            final Symbol sym,
+                            final DiagnosticPosition deferPos) {
+
             this.env = env;
             this.sym = sym;
             this.deferPos = deferPos;
         }
 
-        void annotateTypeLater(final List<JCAnnotation> annotations) {
-            if (annotations.isEmpty()) {
-                return;
-            }
-
-            final DiagnosticPosition deferPos = this.deferPos;
-
-            normal(new Annotate.Worker() {
-                @Override
-                public String toString() {
-                    return "type annotate " + annotations + " onto " + sym + " in " + sym.owner;
-                }
-                @Override
-                public void run() {
-                    JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
-                    DiagnosticPosition prevLintPos = null;
-
-                    if (deferPos != null) {
-                        prevLintPos = deferredLintHandler.setPos(deferPos);
-                    }
-                    try {
-                        actualEnterTypeAnnotations(annotations, env, sym);
-                    } finally {
-                        if (prevLintPos != null)
-                            deferredLintHandler.setPos(prevLintPos);
-                        log.useSource(prev);
-                    }
-                }
-            });
-        }
-
         @Override
         public void visitAnnotatedType(final JCAnnotatedType tree) {
-            annotateTypeLater(tree.annotations);
+            actualEnterTypeAnnotations(tree.annotations, env, sym, deferPos);
             super.visitAnnotatedType(tree);
         }
 
         @Override
         public void visitTypeParameter(final JCTypeParameter tree) {
-            annotateTypeLater(tree.annotations);
+            actualEnterTypeAnnotations(tree.annotations, env, sym, deferPos);
             super.visitTypeParameter(tree);
         }
 
         @Override
         public void visitNewArray(final JCNewArray tree) {
-            annotateTypeLater(tree.annotations);
+            actualEnterTypeAnnotations(tree.annotations, env, sym, deferPos);
             for (List<JCAnnotation> dimAnnos : tree.dimAnnotations)
-                annotateTypeLater(dimAnnos);
+                actualEnterTypeAnnotations(dimAnnos, env, sym, deferPos);
             super.visitNewArray(tree);
         }
 
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java	Wed Feb 26 18:05:02 2014 -0800
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Feb 27 00:29:22 2014 -0500
@@ -774,7 +774,7 @@
             // to the symbol.
             // This prevents having multiple type annotations, just because of
             // lazy constant value evaluation.
-            annotate.typeAnnotate(variable.init, env, null, variable.pos());
+            annotate.annotateTypeLater(variable.init, env, null, variable.pos());
             annotate.flush();
             Type itype = attribExpr(variable.init, env, type);
             if (itype.constValue() != null) {
@@ -1021,7 +1021,7 @@
                 }
 
                 // Attribute all type annotations in the body
-                annotate.typeAnnotate(tree.body, localEnv, m, null);
+                annotate.annotateTypeLater(tree.body, localEnv, m, null);
                 annotate.flush();
 
                 // Attribute method body.
@@ -1050,7 +1050,7 @@
         } else {
             if (tree.init != null) {
                 // Field initializer expression need to be entered.
-                annotate.typeAnnotate(tree.init, env, tree.sym, tree.pos());
+                annotate.annotateTypeLater(tree.init, env, tree.sym, tree.pos());
                 annotate.flush();
             }
         }
@@ -1111,7 +1111,7 @@
             if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;
 
             // Attribute all type annotations in the block
-            annotate.typeAnnotate(tree, localEnv, localEnv.info.scope.owner, null);
+            annotate.annotateTypeLater(tree, localEnv, localEnv.info.scope.owner, null);
             annotate.flush();
 
             {
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Wed Feb 26 18:05:02 2014 -0800
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Thu Feb 27 00:29:22 2014 -0500
@@ -607,7 +607,7 @@
             annotate.annotateLater(tree.mods.annotations, localEnv, m, tree.pos());
             // Visit the signature of the method. Note that
             // TypeAnnotate doesn't descend into the body.
-            annotate.typeAnnotate(tree, localEnv, m, tree.pos());
+            annotate.annotateTypeLater(tree, localEnv, m, tree.pos());
 
             if (tree.defaultValue != null)
                 annotateDefaultValueLater(tree.defaultValue, localEnv, m);
@@ -698,7 +698,7 @@
                 enclScope.enter(v);
             }
             annotate.annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
-            annotate.typeAnnotate(tree.vartype, env, v, tree.pos());
+            annotate.annotateTypeLater(tree.vartype, env, v, tree.pos());
             v.pos = tree.pos;
         } finally {
             annotate.enterDone();
@@ -939,9 +939,9 @@
             Env<AttrContext> baseEnv = baseEnv(tree, env);
 
             if (tree.extending != null)
-                annotate.typeAnnotate(tree.extending, baseEnv, sym, tree.pos());
+                annotate.annotateTypeLater(tree.extending, baseEnv, sym, tree.pos());
             for (JCExpression impl : tree.implementing)
-                annotate.typeAnnotate(impl, baseEnv, sym, tree.pos());
+                annotate.annotateTypeLater(impl, baseEnv, sym, tree.pos());
             annotate.flush();
 
             // Determine supertype.
@@ -1010,7 +1010,7 @@
             attr.attribTypeVariables(tree.typarams, baseEnv);
             // Do this here, where we have the symbol.
             for (JCTypeParameter tp : tree.typarams)
-                annotate.typeAnnotate(tp, baseEnv, sym, tree.pos());
+                annotate.annotateTypeLater(tp, baseEnv, sym, tree.pos());
 
             // Add default constructor if needed.
             if ((c.flags() & INTERFACE) == 0 &&