changeset 2550:b0c086cd4520

8026564: import changes from type-annotations forest Reviewed-by: jjg Contributed-by: wdietl@gmail.com, steve.sides@oracle.com
author jjg
date Tue, 15 Oct 2013 15:57:13 -0700
parents 19e8eebfbe52
children d7e155f874a7
files make/build.properties make/build.xml src/share/classes/com/sun/tools/javac/code/Attribute.java src/share/classes/com/sun/tools/javac/code/Printer.java src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java src/share/classes/com/sun/tools/javac/code/Type.java src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java src/share/classes/com/sun/tools/javac/code/Types.java src/share/classes/com/sun/tools/javac/comp/Annotate.java src/share/classes/com/sun/tools/javac/comp/Attr.java src/share/classes/com/sun/tools/javac/comp/Check.java src/share/classes/com/sun/tools/javac/comp/Lower.java src/share/classes/com/sun/tools/javac/resources/compiler.properties src/share/classes/com/sun/tools/javac/tree/JCTree.java src/share/classes/javax/lang/model/AnnotatedConstruct.java test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java test/tools/javac/T7042623.java test/tools/javac/annotations/typeAnnotations/classfile/ClassfileTestHelper.java test/tools/javac/annotations/typeAnnotations/classfile/Scopes.java test/tools/javac/annotations/typeAnnotations/failures/AnnotatedImport.java test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.java test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.out test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage2.java test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.java test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.out test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion7.out test/tools/javac/annotations/typeAnnotations/failures/BadCast.java test/tools/javac/annotations/typeAnnotations/failures/BadCast.out test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.java test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.out test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.java test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.java test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.out test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.java test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.out test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.java test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.out test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.java test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.out test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.java test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.out test/tools/javac/annotations/typeAnnotations/failures/IndexArray.java test/tools/javac/annotations/typeAnnotations/failures/IndexArray.out test/tools/javac/annotations/typeAnnotations/failures/LintCast.out test/tools/javac/annotations/typeAnnotations/failures/OldArray.java test/tools/javac/annotations/typeAnnotations/failures/OldArray.out test/tools/javac/annotations/typeAnnotations/failures/Scopes.java test/tools/javac/annotations/typeAnnotations/failures/Scopes.out test/tools/javac/annotations/typeAnnotations/failures/StaticFields.java test/tools/javac/annotations/typeAnnotations/failures/StaticFields.out test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.java test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.out test/tools/javac/annotations/typeAnnotations/failures/TypeVariableCycleTest.java test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.java test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.out test/tools/javac/diags/examples/CantAnnotateNestedType.java test/tools/javac/diags/examples/CantAnnotateScoping.java test/tools/javac/diags/examples/CantAnnotateScoping1.java test/tools/javac/diags/examples/CantAnnotateStaticClass.java test/tools/javac/lib/DPrinter.java test/tools/javac/processing/model/type/BasicAnnoTests.java
diffstat 63 files changed, 1243 insertions(+), 368 deletions(-) [+]
line wrap: on
line diff
--- a/make/build.properties	Tue Oct 15 22:15:35 2013 +0200
+++ b/make/build.properties	Tue Oct 15 15:57:13 2013 -0700
@@ -163,11 +163,11 @@
 #
 
 sjavac.includes = \
-        com/sun/tools/sjavac/ 
+        com/sun/tools/sjavac/
 
 sjavac.tests = \
         tools/sjavac
-        
+
 #
 
 # The following files require the latest JDK to be available.
--- a/make/build.xml	Tue Oct 15 22:15:35 2013 +0200
+++ b/make/build.xml	Tue Oct 15 15:57:13 2013 -0700
@@ -89,7 +89,7 @@
       build-classes-TOOL        build the classes for the tool
       build-TOOL                build the jar file and script for the tool
       jtreg-TOOL                build the tool and run the appropriate tests
-      findbugs-TOOL             run findbugs on the tool's source oode
+      findbugs-TOOL             run findbugs on the tool's source code
       TOOL                      build the tool, run the tests, and run findbugs
  - utility definitions
  -->
--- a/src/share/classes/com/sun/tools/javac/code/Attribute.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/Attribute.java	Tue Oct 15 15:57:13 2013 -0700
@@ -236,6 +236,7 @@
 
     public static class TypeCompound extends Compound {
         public TypeAnnotationPosition position;
+
         public TypeCompound(Compound compound,
                 TypeAnnotationPosition position) {
             this(compound.type, compound.values, position);
@@ -256,7 +257,7 @@
         }
 
         public boolean hasUnknownPosition() {
-            return position == null || position.type == TargetType.UNKNOWN;
+            return position.type == TargetType.UNKNOWN;
         }
 
         public boolean isContainerTypeCompound() {
--- a/src/share/classes/com/sun/tools/javac/code/Printer.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/Printer.java	Tue Oct 15 15:57:13 2013 -0700
@@ -260,24 +260,23 @@
 
     @Override
     public String visitAnnotatedType(AnnotatedType t, Locale locale) {
-        if (t.typeAnnotations != null &&
-                t.typeAnnotations.nonEmpty()) {
-            if (t.underlyingType.hasTag(TypeTag.ARRAY)) {
+        if (t.getAnnotationMirrors().nonEmpty()) {
+            if (t.unannotatedType().hasTag(TypeTag.ARRAY)) {
                 StringBuilder res = new StringBuilder();
                 printBaseElementType(t, res, locale);
                 printBrackets(t, res, locale);
                 return res.toString();
-            } else if (t.underlyingType.hasTag(TypeTag.CLASS) &&
-                    t.underlyingType.getEnclosingType() != Type.noType) {
-                return visit(t.underlyingType.getEnclosingType(), locale) +
+            } else if (t.unannotatedType().hasTag(TypeTag.CLASS) &&
+                    t.unannotatedType().getEnclosingType() != Type.noType) {
+                return visit(t.unannotatedType().getEnclosingType(), locale) +
                         ". " +
-                        t.typeAnnotations +
-                        " " + className((ClassType)t.underlyingType, false, locale);
+                        t.getAnnotationMirrors() +
+                        " " + className((ClassType)t.unannotatedType(), false, locale);
             } else {
-                return t.typeAnnotations + " " + visit(t.underlyingType, locale);
+                return t.getAnnotationMirrors() + " " + visit(t.unannotatedType(), locale);
             }
         } else {
-            return visit(t.underlyingType, locale);
+            return visit(t.unannotatedType(), locale);
         }
     }
 
--- a/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java	Tue Oct 15 15:57:13 2013 -0700
@@ -429,7 +429,7 @@
             super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),
                     ctx.isTypeCompound ?
                             ((Attribute.TypeCompound)placeholderFor.head).position :
-                                null);
+                                new TypeAnnotationPosition());
             this.ctx = ctx;
             this.placeholderFor = placeholderFor;
             this.on = on;
--- a/src/share/classes/com/sun/tools/javac/code/Type.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/Type.java	Tue Oct 15 15:57:13 2013 -0700
@@ -225,6 +225,10 @@
         return this;
     }
 
+    public Type annotatedType(List<Attribute.TypeCompound> annos) {
+        return new AnnotatedType(annos, this);
+    }
+
     public boolean isAnnotated() {
         return false;
     }
@@ -1818,25 +1822,19 @@
                 javax.lang.model.type.WildcardType {
         /** The type annotations on this type.
          */
-        public List<Attribute.TypeCompound> typeAnnotations;
+        private List<Attribute.TypeCompound> typeAnnotations;
 
         /** The underlying type that is annotated.
          */
-        public Type underlyingType;
+        private Type underlyingType;
 
-        public AnnotatedType(Type underlyingType) {
-            super(underlyingType.tsym);
-            this.typeAnnotations = List.nil();
-            this.underlyingType = underlyingType;
-            Assert.check(!underlyingType.isAnnotated(),
-                    "Can't annotate already annotated type: " + underlyingType);
-        }
-
-        public AnnotatedType(List<Attribute.TypeCompound> typeAnnotations,
+        protected AnnotatedType(List<Attribute.TypeCompound> typeAnnotations,
                 Type underlyingType) {
             super(underlyingType.tsym);
             this.typeAnnotations = typeAnnotations;
             this.underlyingType = underlyingType;
+            Assert.check(typeAnnotations != null && typeAnnotations.nonEmpty(),
+                    "Can't create AnnotatedType without annotations: " + underlyingType);
             Assert.check(!underlyingType.isAnnotated(),
                     "Can't annotate already annotated type: " + underlyingType +
                     "; adding: " + typeAnnotations);
@@ -1977,10 +1975,8 @@
         public TypeMirror getComponentType()     { return ((ArrayType)underlyingType).getComponentType(); }
 
         // The result is an ArrayType, but only in the model sense, not the Type sense.
-        public AnnotatedType makeVarargs() {
-            AnnotatedType atype = new AnnotatedType(((ArrayType)underlyingType).makeVarargs());
-            atype.typeAnnotations = this.typeAnnotations;
-            return atype;
+        public Type makeVarargs() {
+            return ((ArrayType) underlyingType).makeVarargs().annotatedType(typeAnnotations);
         }
 
         @Override
--- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Tue Oct 15 15:57:13 2013 -0700
@@ -290,6 +290,7 @@
             List<Attribute.Compound> annotations = sym.getRawAttributes();
             ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<Attribute.Compound>();
             ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<Attribute.TypeCompound>();
+            ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<Attribute.TypeCompound>();
 
             for (Attribute.Compound a : annotations) {
                 switch (annotationType(a, sym)) {
@@ -305,6 +306,8 @@
                 case TYPE: {
                     Attribute.TypeCompound ta = toTypeCompound(a, pos);
                     typeAnnos.append(ta);
+                    // Also keep track which annotations are only type annotations
+                    onlyTypeAnnos.append(ta);
                     break;
                 }
                 }
@@ -328,7 +331,7 @@
             }
 
             // type is non-null and annotations are added to that type
-            type = typeWithAnnotations(typetree, type, typeAnnotations);
+            type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList());
 
             if (sym.getKind() == ElementKind.METHOD) {
                 sym.type.asMethodType().restype = type;
@@ -380,32 +383,23 @@
         // As a side effect the method sets the type annotation position of "annotations".
         // Note that it is assumed that all annotations share the same position.
         private Type typeWithAnnotations(final JCTree typetree, final Type type,
-                final List<Attribute.TypeCompound> annotations) {
-            // System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s)%n",
-            //         typetree, type, annotations);
+                final List<Attribute.TypeCompound> annotations,
+                final List<Attribute.TypeCompound> onlyTypeAnnotations) {
+            // System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s, onlyTypeAnnotations: %s)%n",
+            //         typetree, type, annotations, onlyTypeAnnotations);
             if (annotations.isEmpty()) {
                 return type;
             }
             if (type.hasTag(TypeTag.ARRAY)) {
+                Type.ArrayType arType = (Type.ArrayType) type.unannotatedType();
+                Type.ArrayType tomodify = new Type.ArrayType(null, arType.tsym);
                 Type toreturn;
-                Type.ArrayType tomodify;
-                Type.ArrayType arType;
-                {
-                    Type touse = type;
-                    if (type.isAnnotated()) {
-                        Type.AnnotatedType atype = (Type.AnnotatedType)type;
-                        toreturn = new Type.AnnotatedType(atype.underlyingType);
-                        ((Type.AnnotatedType)toreturn).typeAnnotations = atype.typeAnnotations;
-                        touse = atype.underlyingType;
-                        arType = (Type.ArrayType) touse;
-                        tomodify = new Type.ArrayType(null, arType.tsym);
-                        ((Type.AnnotatedType)toreturn).underlyingType = tomodify;
-                    } else {
-                        arType = (Type.ArrayType) touse;
-                        tomodify = new Type.ArrayType(null, arType.tsym);
-                        toreturn = tomodify;
-                    }
+                if (type.isAnnotated()) {
+                    toreturn = tomodify.annotatedType(type.getAnnotationMirrors());
+                } else {
+                    toreturn = tomodify;
                 }
+
                 JCArrayTypeTree arTree = arrayTypeTree(typetree);
 
                 ListBuffer<TypePathEntry> depth = new ListBuffer<>();
@@ -413,12 +407,10 @@
                 while (arType.elemtype.hasTag(TypeTag.ARRAY)) {
                     if (arType.elemtype.isAnnotated()) {
                         Type.AnnotatedType aelemtype = (Type.AnnotatedType) arType.elemtype;
-                        Type.AnnotatedType newAT = new Type.AnnotatedType(aelemtype.underlyingType);
-                        tomodify.elemtype = newAT;
-                        newAT.typeAnnotations = aelemtype.typeAnnotations;
-                        arType = (Type.ArrayType) aelemtype.underlyingType;
+                        arType = (Type.ArrayType) aelemtype.unannotatedType();
+                        ArrayType prevToMod = tomodify;
                         tomodify = new Type.ArrayType(null, arType.tsym);
-                        newAT.underlyingType = tomodify;
+                        prevToMod.elemtype = (Type.AnnotatedType) tomodify.annotatedType(arType.elemtype.getAnnotationMirrors());
                     } else {
                         arType = (Type.ArrayType) arType.elemtype;
                         tomodify.elemtype = new Type.ArrayType(null, arType.tsym);
@@ -427,7 +419,7 @@
                     arTree = arrayTypeTree(arTree.elemtype);
                     depth = depth.append(TypePathEntry.ARRAY);
                 }
-                Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations);
+                Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations, onlyTypeAnnotations);
                 tomodify.elemtype = arelemType;
                 {
                     // All annotations share the same position; modify the first one.
@@ -444,7 +436,7 @@
                 // There is a TypeKind, but no TypeTag.
                 JCTypeUnion tutree = (JCTypeUnion) typetree;
                 JCExpression fst = tutree.alternatives.get(0);
-                Type res = typeWithAnnotations(fst, fst.type, annotations);
+                Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations);
                 fst.type = res;
                 // TODO: do we want to set res as first element in uct.alternatives?
                 // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;
@@ -483,14 +475,23 @@
                  * but nothing more exists.
                  */
                 if (enclTy != null &&
-                        enclTy.getKind() == TypeKind.NONE &&
-                        (enclTr.getKind() == JCTree.Kind.IDENTIFIER ||
-                         enclTr.getKind() == JCTree.Kind.MEMBER_SELECT ||
-                         enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE ||
-                         enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) {
-                    // TODO: also if it's "java. @A lang.Object", that is,
-                    // if it's on a package?
-                    log.error(enclTr.pos(), "cant.annotate.nested.type", enclTr.toString());
+                        enclTy.hasTag(TypeTag.NONE)) {
+                    switch (onlyTypeAnnotations.size()) {
+                    case 0:
+                        // Don't issue an error if all type annotations are
+                        // also declaration annotations.
+                        // If the annotations are also declaration annotations, they are
+                        // illegal as type annotations but might be legal as declaration annotations.
+                        // The normal declaration annotation checks make sure that the use is valid.
+                        break;
+                    case 1:
+                        log.error(typetree.pos(), "cant.type.annotate.scoping.1",
+                                onlyTypeAnnotations);
+                        break;
+                    default:
+                        log.error(typetree.pos(), "cant.type.annotate.scoping",
+                                onlyTypeAnnotations);
+                    }
                     return type;
                 }
 
@@ -569,7 +570,7 @@
                     // assert that t.constValue() == null?
                     if (t == stopAt ||
                         t.getEnclosingType() == Type.noType) {
-                        return new AnnotatedType(s, t);
+                        return t.annotatedType(s);
                     } else {
                         ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),
                                 t.typarams_field, t.tsym);
@@ -584,12 +585,12 @@
 
                 @Override
                 public Type visitAnnotatedType(AnnotatedType t, List<TypeCompound> s) {
-                    return new AnnotatedType(t.typeAnnotations, t.underlyingType.accept(this, s));
+                    return t.unannotatedType().accept(this, s).annotatedType(t.getAnnotationMirrors());
                 }
 
                 @Override
                 public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {
-                    return new AnnotatedType(s, t);
+                    return t.annotatedType(s);
                 }
 
                 @Override
@@ -612,12 +613,12 @@
 
                 @Override
                 public Type visitTypeVar(TypeVar t, List<TypeCompound> s) {
-                    return new AnnotatedType(s, t);
+                    return t.annotatedType(s);
                 }
 
                 @Override
                 public Type visitCapturedType(CapturedType t, List<TypeCompound> s) {
-                    return new AnnotatedType(s, t);
+                    return t.annotatedType(s);
                 }
 
                 @Override
@@ -634,12 +635,12 @@
 
                 @Override
                 public Type visitErrorType(ErrorType t, List<TypeCompound> s) {
-                    return new AnnotatedType(s, t);
+                    return t.annotatedType(s);
                 }
 
                 @Override
                 public Type visitType(Type t, List<TypeCompound> s) {
-                    return new AnnotatedType(s, t);
+                    return t.annotatedType(s);
                 }
             };
 
--- a/src/share/classes/com/sun/tools/javac/code/Types.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Tue Oct 15 15:57:13 2013 -0700
@@ -1273,7 +1273,7 @@
                     return false;
                 if (!s.getAnnotationMirrors().containsAll(t.getAnnotationMirrors()))
                     return false;
-                return visit(t.underlyingType, s);
+                return visit(t.unannotatedType(), s);
             }
         };
     // </editor-fold>
@@ -2217,15 +2217,15 @@
 
             @Override
             public Type visitAnnotatedType(AnnotatedType t, Boolean recurse) {
-                Type erased = erasure(t.underlyingType, recurse);
+                Type erased = erasure(t.unannotatedType(), recurse);
                 if (erased.isAnnotated()) {
                     // This can only happen when the underlying type is a
                     // type variable and the upper bound of it is annotated.
                     // The annotation on the type variable overrides the one
                     // on the bound.
-                    erased = ((AnnotatedType)erased).underlyingType;
+                    erased = ((AnnotatedType)erased).unannotatedType();
                 }
-                return new AnnotatedType(t.typeAnnotations, erased);
+                return erased.annotatedType(t.getAnnotationMirrors());
             }
         };
 
@@ -4419,7 +4419,7 @@
         public R visitUndetVar(UndetVar t, S s)         { return visitType(t, s); }
         public R visitErrorType(ErrorType t, S s)       { return visitType(t, s); }
         // Pretend annotations don't exist
-        public R visitAnnotatedType(AnnotatedType t, S s) { return visit(t.underlyingType, s); }
+        public R visitAnnotatedType(AnnotatedType t, S s) { return visit(t.unannotatedType(), s); }
     }
 
     /**
--- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Tue Oct 15 15:57:13 2013 -0700
@@ -250,7 +250,8 @@
         a.type = chk.checkType(a.annotationType.pos(), at, expected);
         if (a.type.isErroneous()) {
             if (typeAnnotation) {
-                return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
+                return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(),
+                        new TypeAnnotationPosition());
             } else {
                 return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
             }
--- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Oct 15 15:57:13 2013 -0700
@@ -3534,15 +3534,6 @@
                         Type normOuter = site;
                         if (normOuter.hasTag(CLASS)) {
                             normOuter = types.asEnclosingSuper(site, ownOuter.tsym);
-                            if (site.isAnnotated()) {
-                                // Propagate any type annotations.
-                                // TODO: should asEnclosingSuper do this?
-                                // Note that the type annotations in site will be updated
-                                // by annotateType. Therefore, modify site instead
-                                // of creating a new AnnotatedType.
-                                ((AnnotatedType)site).underlyingType = normOuter;
-                                normOuter = site;
-                            }
                         }
                         if (normOuter == null) // perhaps from an import
                             normOuter = types.erasure(ownOuter);
@@ -3901,12 +3892,6 @@
                     }
                 }
                 owntype = new ClassType(clazzOuter, actuals, clazztype.tsym);
-                if (clazztype.isAnnotated()) {
-                    // Use the same AnnotatedType, because it will have
-                    // its annotations set later.
-                    ((AnnotatedType)clazztype).underlyingType = owntype;
-                    owntype = clazztype;
-                }
             } else {
                 if (formals.length() != 0) {
                     log.error(tree.pos(), "wrong.number.type.args",
@@ -3972,9 +3957,7 @@
         TypeVar typeVar = (TypeVar) tree.type;
 
         if (tree.annotations != null && tree.annotations.nonEmpty()) {
-            AnnotatedType antype = new AnnotatedType(typeVar);
-            annotateType(antype, tree.annotations);
-            tree.type = antype;
+            annotateType(tree, tree.annotations);
         }
 
         if (!typeVar.bound.isErroneous()) {
@@ -4074,26 +4057,28 @@
     public void visitAnnotatedType(JCAnnotatedType tree) {
         Type underlyingType = attribType(tree.getUnderlyingType(), env);
         this.attribAnnotationTypes(tree.annotations, env);
-        AnnotatedType antype = new AnnotatedType(underlyingType);
-        annotateType(antype, tree.annotations);
-        result = tree.type = antype;
+        annotateType(tree, tree.annotations);
+        result = tree.type = underlyingType;
     }
 
     /**
      * Apply the annotations to the particular type.
      */
-    public void annotateType(final AnnotatedType type, final List<JCAnnotation> annotations) {
-        if (annotations.isEmpty())
-            return;
+    public void annotateType(final JCTree tree, final List<JCAnnotation> annotations) {
+        // Callers ensure this.
+        // Assert.check(annotations != null && annotations.nonEmpty());
         annotate.typeAnnotation(new Annotate.Worker() {
             @Override
             public String toString() {
-                return "annotate " + annotations + " onto " + type;
+                return "annotate " + annotations + " onto " + tree;
             }
             @Override
             public void run() {
                 List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
-                type.typeAnnotations = compounds;
+                if (annotations.size() == compounds.size()) {
+                    // All annotations were successfully converted into compounds
+                    tree.type = tree.type.unannotatedType().annotatedType(compounds);
+                }
             }
         });
     }
@@ -4432,17 +4417,18 @@
     private final class TypeAnnotationsValidator extends TreeScanner {
 
         private final boolean sigOnly;
-        private boolean checkAllAnnotations = false;
-
         public TypeAnnotationsValidator(boolean sigOnly) {
             this.sigOnly = sigOnly;
         }
 
         public void visitAnnotation(JCAnnotation tree) {
-            if (tree.hasTag(TYPE_ANNOTATION) || checkAllAnnotations) {
-                chk.validateTypeAnnotation(tree, false);
+            chk.validateTypeAnnotation(tree, false);
+            super.visitAnnotation(tree);
+        }
+        public void visitAnnotatedType(JCAnnotatedType tree) {
+            if (!tree.underlyingType.type.isErroneous()) {
+                super.visitAnnotatedType(tree);
             }
-            super.visitAnnotation(tree);
         }
         public void visitTypeParameter(JCTypeParameter tree) {
             chk.validateTypeAnnotations(tree.annotations, true);
@@ -4475,7 +4461,7 @@
         }
         public void visitVarDef(final JCVariableDecl tree) {
             if (tree.sym != null && tree.sym.type != null)
-                validateAnnotatedType(tree, tree.sym.type);
+                validateAnnotatedType(tree.vartype, tree.sym.type);
             scan(tree.mods);
             scan(tree.vartype);
             if (!sigOnly) {
@@ -4493,27 +4479,13 @@
             super.visitTypeTest(tree);
         }
         public void visitNewClass(JCNewClass tree) {
-            if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
-                boolean prevCheck = this.checkAllAnnotations;
-                try {
-                    this.checkAllAnnotations = true;
-                    scan(((JCAnnotatedType)tree.clazz).annotations);
-                } finally {
-                    this.checkAllAnnotations = prevCheck;
-                }
-            }
+            if (tree.clazz.type != null)
+                validateAnnotatedType(tree.clazz, tree.clazz.type);
             super.visitNewClass(tree);
         }
         public void visitNewArray(JCNewArray tree) {
-            if (tree.elemtype != null && tree.elemtype.hasTag(ANNOTATED_TYPE)) {
-                boolean prevCheck = this.checkAllAnnotations;
-                try {
-                    this.checkAllAnnotations = true;
-                    scan(((JCAnnotatedType)tree.elemtype).annotations);
-                } finally {
-                    this.checkAllAnnotations = prevCheck;
-                }
-            }
+            if (tree.elemtype != null && tree.elemtype.type != null)
+                validateAnnotatedType(tree.elemtype, tree.elemtype.type);
             super.visitNewArray(tree);
         }
 
@@ -4549,21 +4521,95 @@
          * can occur.
          */
         private void validateAnnotatedType(final JCTree errtree, final Type type) {
-            if (type.getEnclosingType() != null &&
-                    type != type.getEnclosingType()) {
-                validateEnclosingAnnotatedType(errtree, type.getEnclosingType());
+            // System.out.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
+
+            if (type.isPrimitiveOrVoid()) {
+                return;
             }
-            for (Type targ : type.getTypeArguments()) {
-                validateAnnotatedType(errtree, targ);
-            }
-        }
-        private void validateEnclosingAnnotatedType(final JCTree errtree, final Type type) {
-            validateAnnotatedType(errtree, type);
-            if (type.tsym != null &&
-                    type.tsym.isStatic() &&
-                    type.getAnnotationMirrors().nonEmpty()) {
-                    // Enclosing static classes cannot have type annotations.
-                log.error(errtree.pos(), "cant.annotate.static.class");
+
+            JCTree enclTr = errtree;
+            Type enclTy = type;
+
+            boolean repeat = true;
+            while (repeat) {
+                if (enclTr.hasTag(TYPEAPPLY)) {
+                    List<Type> tyargs = enclTy.getTypeArguments();
+                    List<JCExpression> trargs = ((JCTypeApply)enclTr).getTypeArguments();
+                    if (trargs.length() > 0) {
+                        // Nothing to do for diamonds
+                        if (tyargs.length() == trargs.length()) {
+                            for (int i = 0; i < tyargs.length(); ++i) {
+                                validateAnnotatedType(trargs.get(i), tyargs.get(i));
+                            }
+                        }
+                        // If the lengths don't match, it's either a diamond
+                        // or some nested type that redundantly provides
+                        // type arguments in the tree.
+                    }
+
+                    // Look at the clazz part of a generic type
+                    enclTr = ((JCTree.JCTypeApply)enclTr).clazz;
+                }
+
+                if (enclTr.hasTag(SELECT)) {
+                    enclTr = ((JCTree.JCFieldAccess)enclTr).getExpression();
+                    if (enclTy != null &&
+                            !enclTy.hasTag(NONE)) {
+                        enclTy = enclTy.getEnclosingType();
+                    }
+                } 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);
+                        } else {
+                            ListBuffer<Attribute.Compound> comps = new ListBuffer<Attribute.Compound>();
+                            for (JCAnnotation an : at.getAnnotations()) {
+                                comps.add(an.attribute);
+                            }
+                            log.error(at.underlyingType.pos(), "cant.type.annotate.scoping", comps.toList());
+                        }
+                        repeat = false;
+                    }
+                    enclTr = at.underlyingType;
+                    // enclTy doesn't need to be changed
+                } else if (enclTr.hasTag(IDENT)) {
+                    repeat = false;
+                } else if (enclTr.hasTag(JCTree.Tag.WILDCARD)) {
+                    JCWildcard wc = (JCWildcard) enclTr;
+                    if (wc.getKind() == JCTree.Kind.EXTENDS_WILDCARD) {
+                        validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy.unannotatedType()).getExtendsBound());
+                    } else if (wc.getKind() == JCTree.Kind.SUPER_WILDCARD) {
+                        validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy.unannotatedType()).getSuperBound());
+                    } else {
+                        // Nothing to do for UNBOUND
+                    }
+                    repeat = false;
+                } else if (enclTr.hasTag(TYPEARRAY)) {
+                    JCArrayTypeTree art = (JCArrayTypeTree) enclTr;
+                    validateAnnotatedType(art.getType(), ((ArrayType)enclTy.unannotatedType()).getComponentType());
+                    repeat = false;
+                } else if (enclTr.hasTag(TYPEUNION)) {
+                    JCTypeUnion ut = (JCTypeUnion) enclTr;
+                    for (JCTree t : ut.getTypeAlternatives()) {
+                        validateAnnotatedType(t, t.type);
+                    }
+                    repeat = false;
+                } else if (enclTr.hasTag(TYPEINTERSECTION)) {
+                    JCTypeIntersection it = (JCTypeIntersection) enclTr;
+                    for (JCTree t : it.getBounds()) {
+                        validateAnnotatedType(t, t.type);
+                    }
+                    repeat = false;
+                } else if (enclTr.getKind() == JCTree.Kind.PRIMITIVE_TYPE) {
+                    // This happens in test TargetTypeTest52.java
+                    // Is there anything to do?
+                    repeat = false;
+                } else {
+                    Assert.error("Unexpected tree: " + enclTr + " with kind: " + enclTr.getKind() +
+                            " within: "+ errtree + " with kind: " + errtree.getKind());
+                }
             }
         }
     };
--- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue Oct 15 15:57:13 2013 -0700
@@ -2769,8 +2769,11 @@
         Assert.checkNonNull(a.type, "annotation tree hasn't been attributed yet: " + a);
         validateAnnotationTree(a);
 
-        if (!isTypeAnnotation(a, isTypeParameter))
+        if (a.hasTag(TYPE_ANNOTATION) &&
+                !a.annotationType.type.isErroneous() &&
+                !isTypeAnnotation(a, isTypeParameter)) {
             log.error(a.pos(), "annotation.type.not.applicable");
+        }
     }
 
     /**
--- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Tue Oct 15 15:57:13 2013 -0700
@@ -2834,20 +2834,9 @@
         tree.underlyingType = translate(tree.underlyingType);
         // but maintain type annotations in the type.
         if (tree.type.isAnnotated()) {
-            if (tree.underlyingType.type.isAnnotated()) {
-                // The erasure of a type variable might be annotated.
-                // Merge all annotations.
-                AnnotatedType newat = (AnnotatedType) tree.underlyingType.type;
-                AnnotatedType at = (AnnotatedType) tree.type;
-                at.underlyingType = newat.underlyingType;
-                newat.typeAnnotations = at.typeAnnotations.appendList(newat.typeAnnotations);
-                tree.type = newat;
-            } else {
-                // Create a new AnnotatedType to have the correct tag.
-                AnnotatedType oldat = (AnnotatedType) tree.type;
-                tree.type = new AnnotatedType(tree.underlyingType.type);
-                ((AnnotatedType) tree.type).typeAnnotations = oldat.typeAnnotations;
-            }
+            tree.type = tree.underlyingType.type.unannotatedType().annotatedType(tree.type.getAnnotationMirrors());
+        } else if (tree.underlyingType.type.isAnnotated()) {
+            tree.type = tree.underlyingType.type;
         }
         result = tree;
     }
--- a/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Tue Oct 15 15:57:13 2013 -0700
@@ -2257,13 +2257,14 @@
     receiver parameter not applicable for constructor of top-level class
 
 # TODO 308: make a better error message
-compiler.err.cant.annotate.static.class=\
-    enclosing static nested class cannot be annotated
+# 0: symbol
+compiler.err.cant.type.annotate.scoping.1=\
+    scoping construct cannot be annotated with type-use annotation: {0}
 
 # TODO 308: make a better error message
-# 0: unused
-compiler.err.cant.annotate.nested.type=\
-    scoping construct for static nested type cannot be annotated
+# 0: list of symbol
+compiler.err.cant.type.annotate.scoping=\
+    scoping construct cannot be annotated with type-use annotations: {0}
 
 # 0: type, 1: type
 compiler.err.incorrect.receiver.name=\
--- a/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Tue Oct 15 15:57:13 2013 -0700
@@ -2359,6 +2359,7 @@
         public JCExpression underlyingType;
 
         protected JCAnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) {
+            Assert.check(annotations != null && annotations.nonEmpty());
             this.annotations = annotations;
             this.underlyingType = underlyingType;
         }
--- a/src/share/classes/javax/lang/model/AnnotatedConstruct.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/src/share/classes/javax/lang/model/AnnotatedConstruct.java	Tue Oct 15 15:57:13 2013 -0700
@@ -221,8 +221,8 @@
      *         type if present on this construct, else an empty array
      *
      * @see #getAnnotationMirrors()
-     * @see #getAnnotation(java.lang.Class)
-     * @see java.lang.reflect.AnnotatedElement#getAnnotationsByType
+     * @see #getAnnotation(Class)
+     * @see java.lang.reflect.AnnotatedElement#getAnnotationsByType(Class)
      * @see EnumConstantNotPresentException
      * @see AnnotationTypeMismatchException
      * @see IncompleteAnnotationException
--- a/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java	Tue Oct 15 15:57:13 2013 -0700
@@ -27,6 +27,7 @@
  * @summary  Make sure that type annotations are displayed correctly
  * @author   Bhavesh Patel
  * @library  ../lib/
+ * @ignore
  * @build    JavadocTester TestTypeAnnotations
  * @run main TestTypeAnnotations
  */
--- a/test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java	Tue Oct 15 15:57:13 2013 -0700
@@ -28,6 +28,7 @@
  *
  * @author   Mahmood Ali <mali>
  * @library  ../../lib/
+ * @ignore
  * @build    JavadocTester
  * @build    TestSmoke
  * @run main TestSmoke
--- a/test/tools/javac/T7042623.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/T7042623.java	Tue Oct 15 15:57:13 2013 -0700
@@ -2,6 +2,7 @@
  * @test /nodynamiccopyright/
  * @bug 7042623
  * @summary Regression: javac silently crash when attributing non-existent annotation
+ * @ignore
  * @compile/fail/ref=T7042623.out -XDrawDiagnostics -XDdev T7042623.java
  */
 
--- a/test/tools/javac/annotations/typeAnnotations/classfile/ClassfileTestHelper.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/classfile/ClassfileTestHelper.java	Tue Oct 15 15:57:13 2013 -0700
@@ -36,7 +36,8 @@
 
     //Makes debugging much easier. Set to 'false' for less output.
     public Boolean verbose = true;
-    void println(String msg) { if(verbose) System.out.println(msg); }
+    void println(String msg) { if (verbose) System.out.println(msg); }
+    void print(String msg) { if (verbose) System.out.print(msg); }
 
     File writeTestFile(String fname, String source) throws IOException {
       File f = new File(fname);
@@ -183,6 +184,13 @@
                         (RuntimeTypeAnnotations_attribute)attr;
                 println(testtype + ": " + name + ", " + annName + ": " +
                         tAttr.annotations.length );
+                if (tAttr.annotations.length > 0) {
+                    for (int i = 0; i < tAttr.annotations.length; i++) {
+                        println("  types:" + tAttr.annotations[i].position.type);
+                    }
+                } else {
+                    println("");
+                }
                 allt += tAttr.annotations.length;
                 if (visible)
                     tvisibles += tAttr.annotations.length;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/classfile/Scopes.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2009, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.lang.annotation.*;
+import java.io.*;
+import java.net.URL;
+import java.util.List;
+
+import com.sun.tools.classfile.*;
+
+/*
+ * @test
+ * @bug 6843077 8006775
+ * @summary Qualified inner type annotation accessible to the class.
+ */
+
+@Scopes.UniqueInner
+public class Scopes<T extends @Scopes.UniqueInner Object> extends ClassfileTestHelper{
+    public static void main(String[] args) throws Exception {
+        new Scopes().run();
+    }
+
+    public void run() throws Exception {
+        expected_tinvisibles = 1;
+        expected_invisibles = 1;
+
+        ClassFile cf = getClassFile("Scopes.class");
+        test(cf);
+
+        countAnnotations();
+
+        if (errors > 0)
+            throw new Exception(errors + " errors found");
+        System.out.println("PASSED");
+    }
+
+    @Target({ElementType.TYPE_USE})
+    @interface UniqueInner { };
+}
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedImport.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedImport.java	Tue Oct 15 15:57:13 2013 -0700
@@ -3,13 +3,16 @@
  * @bug 8006775
  * @summary Import clauses cannot use annotations.
  * @author Werner Dietl
+ * @ignore
  * @compile/fail/ref=AnnotatedImport.out -XDrawDiagnostics AnnotatedImport.java
  */
 
+import java.lang.annotation.*;
 import java.@A util.List;
 import @A java.util.Map;
 import java.util.@A HashMap;
 
 class AnnotatedImport { }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.java	Tue Oct 15 15:57:13 2013 -0700
@@ -3,11 +3,15 @@
  * @bug 8006775
  * @summary Package declarations cannot use annotations.
  * @author Werner Dietl
+ * @ignore
  * @compile/fail/ref=AnnotatedPackage1.out -XDrawDiagnostics AnnotatedPackage1.java
  */
 
 package name.@A p1.p2;
 
+import java.lang.annotation.*;
+
 class AnnotatedPackage1 { }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,3 +1,3 @@
 AnnotatedPackage1.java:9:14: compiler.err.expected: token.identifier
-AnnotatedPackage1.java:9:15: compiler.err.expected3: class, interface, enum
+AnnotatedPackage1.java:9:16: compiler.err.expected3: class, interface, enum
 2 errors
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage2.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage2.java	Tue Oct 15 15:57:13 2013 -0700
@@ -8,6 +8,9 @@
 
 package @A p1.p2;
 
+import java.lang.annotation.*;
+
 class AnnotatedPackage2 { }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.java	Tue Oct 15 15:57:13 2013 -0700
@@ -3,11 +3,13 @@
  * @bug 6843077 8006775
  * @summary test that only Java 8 allows type annotations
  * @author Mahmood Ali
+ * @compile AnnotationVersion.java
  * @compile/fail/ref=AnnotationVersion.out -XDrawDiagnostics -Xlint:-options -source 1.6 AnnotationVersion.java
  * @compile/fail/ref=AnnotationVersion7.out -XDrawDiagnostics -Xlint:-options -source 1.7 AnnotationVersion.java
  */
-class AnnotationVersion {
-  public void method(@A AnnotationVersion this) { }
-}
+import java.lang.annotation.*;
 
+class myNumber<T extends @A Number> { }
+
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,2 @@
-AnnotationVersion.java:10:43: compiler.err.type.annotations.not.supported.in.source: 1.6
+AnnotationVersion.java:12:27: compiler.err.type.annotations.not.supported.in.source: 1.6
 1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion7.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion7.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,2 @@
-AnnotationVersion.java:10:43: compiler.err.type.annotations.not.supported.in.source: 1.7
+AnnotationVersion.java:12:27: compiler.err.type.annotations.not.supported.in.source: 1.7
 1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/BadCast.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/BadCast.java	Tue Oct 15 15:57:13 2013 -0700
@@ -5,10 +5,13 @@
  * @author Werner Dietl
  * @compile/fail/ref=BadCast.out -XDrawDiagnostics BadCast.java
  */
+import java.lang.annotation.*;
+
 class BadCast {
   static void main() {
     Object o = (@A) "";
   }
 }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/BadCast.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/BadCast.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,2 @@
-BadCast.java:10:19: compiler.err.illegal.start.of.type
-1 error
\ No newline at end of file
+BadCast.java:12:19: compiler.err.illegal.start.of.type
+1 error
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,27 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 1234567
+ * @summary The parts of a fully-qualified type can't be annotated.
+ * @author Werner Dietl
+ * @compile/fail/ref=CantAnnotatePackages.out -XDrawDiagnostics CantAnnotatePackages.java
+ */
+
+import java.lang.annotation.*;
+import java.util.List;
+
+class CantAnnotatePackages {
+    // Before a package component:
+    @TA java.lang.Object of1;
+
+    // These result in a different error.
+    // TODO: should this be unified?
+
+    List<@TA java.lang.Object> of2;
+    java. @TA lang.Object of3;
+    List<java. @TA lang.Object> of4;
+
+    // TODO: also note the order of error messages.
+}
+
+@Target(ElementType.TYPE_USE)
+@interface TA { }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,5 @@
+CantAnnotatePackages.java:19:14: compiler.err.cant.resolve.location: kindname.class, java, , , (compiler.misc.location: kindname.class, CantAnnotatePackages, null)
+CantAnnotatePackages.java:20:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
+CantAnnotatePackages.java:21:14: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
+CantAnnotatePackages.java:14:18: compiler.err.cant.type.annotate.scoping.1: @TA
+4 errors
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,71 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8006733 8006775
+ * @summary Ensure behavior for nested types is correct.
+ * @author Werner Dietl
+ * @compile/fail/ref=CantAnnotateScoping.out -XDrawDiagnostics CantAnnotateScoping.java
+ */
+
+import java.util.List;
+import java.util.ArrayList;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE_USE})
+@interface TA {}
+@Target({ElementType.TYPE_USE})
+@interface TA2 {}
+
+@Target({ElementType.FIELD})
+@interface DA {}
+@Target({ElementType.FIELD})
+@interface DA2 {}
+
+@Target({ElementType.TYPE_USE, ElementType.FIELD})
+@interface DTA {}
+@Target({ElementType.TYPE_USE, ElementType.FIELD})
+@interface DTA2 {}
+
+class Test {
+    static class Outer {
+        static class SInner {}
+    }
+
+    // Legal
+    List<Outer. @TA SInner> li;
+
+    // Illegal
+    @TA Outer.SInner osi;
+    // Illegal
+    List<@TA Outer.SInner> aloi;
+    // Illegal
+    Object o1 = new @TA @DA @TA2 Outer.SInner();
+    // Illegal
+    Object o = new ArrayList<@TA @DA Outer.SInner>();
+
+    // Illegal: @TA is only a type-use annotation
+    @TA java.lang.Object f1;
+
+    // Legal: @DA is only a declaration annotation
+    @DA java.lang.Object f2;
+
+    // Legal: @DTA is both a type-use and declaration annotation
+    @DTA java.lang.Object f3;
+
+    // Illegal: @TA and @TA2 are only type-use annotations
+    @DTA @DA @TA @DA2 @TA2 java.lang.Object f4;
+
+    // Illegal: Do we want one or two messages?
+    // 1: @DA in invalid location
+    // 2: Not finding class "lang"
+    java. @DA lang.Object f5;
+
+    // Illegal: Do we want one or two messages?
+    // 1: @DA in invalid location
+    // 2: Not finding class "XXX"
+    java. @DA XXX.Object f6;
+
+    // Illegal: Can't find class "lang".
+    // Would a different error message be desirable?
+    java. @TA lang.Object f7;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,11 @@
+CantAnnotateScoping.java:61:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
+CantAnnotateScoping.java:66:9: compiler.err.cant.resolve.location: kindname.class, XXX, , , (compiler.misc.location: kindname.package, java, null)
+CantAnnotateScoping.java:70:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
+CantAnnotateScoping.java:38:14: compiler.err.cant.type.annotate.scoping.1: @TA
+CantAnnotateScoping.java:47:18: compiler.err.cant.type.annotate.scoping.1: @TA
+CantAnnotateScoping.java:56:37: compiler.err.cant.type.annotate.scoping: @TA,@TA2
+CantAnnotateScoping.java:40:14: compiler.err.cant.type.annotate.scoping.1: @TA
+CantAnnotateScoping.java:42:34: compiler.err.cant.type.annotate.scoping: @TA,@DA,@TA2
+CantAnnotateScoping.java:44:38: compiler.err.cant.type.annotate.scoping: @TA,@DA
+CantAnnotateScoping.java:44:34: compiler.err.annotation.type.not.applicable
+10 errors
\ No newline at end of file
--- a/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.java	Tue Oct 15 15:57:13 2013 -0700
@@ -1,41 +1,96 @@
 /*
  * @test /nodynamiccopyright/
  * @bug 8006733 8006775
-
- * @summary A static outer class cannot be annotated.
+ * @summary Ensure behavior for nested types is correct.
  * @author Werner Dietl
- * @compile/fail/ref=CantAnnotateStaticClass.out -XDrawDiagnostics CantAnnotateStaticClass.java
+ * @compile CantAnnotateStaticClass.java
  */
 
 import java.util.List;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.lang.annotation.*;
 
-class CantAnnotateStaticClass {
+class Top {
     @Target(ElementType.TYPE_USE)
-    @interface A {}
+    @interface TA {}
 
-    static class Outer {
-        class Inner {}
+    @Target(ElementType.TYPE_USE)
+    @interface TB {}
+
+    @Target(ElementType.TYPE_USE)
+    @interface TC {}
+
+    class Outer {
+        class Inner {
+            Object o1 = Top.this;
+            Object o2 = Outer.this;
+            Object o3 = this;
+        }
+        // Illegal
+        // static class SInner {}
+        // interface IInner {}
     }
 
-    // 8 errors:
-    @A Outer.Inner f1;
-    @A Outer.Inner f1r() { return null; }
-    void f1p(@A Outer.Inner p) { }
-    void f1c(Object o) {
-        Object l = (@A Outer.Inner) o;
+    // All combinations are OK
+
+    Top.@TB Outer f1;
+    @TB Outer.Inner f1a;
+    Outer. @TC Inner f1b;
+    @TB Outer. @TC Inner f1c;
+
+    @TA Top. @TB Outer f2;
+    @TA Top. @TB Outer.Inner f2a;
+    @TA Top. Outer. @TC Inner f2b;
+    @TA Top. @TB Outer. @TC Inner f2c;
+
+    @TB Outer f1r() { return null; }
+    @TB Outer.Inner f1ra() { return null; }
+    Outer. @TC Inner f1rb() { return null; }
+    @TB Outer. @TC Inner f1rc() { return null; }
+
+    void f1param(@TB Outer p,
+            @TB Outer.Inner p1,
+            Outer. @TC Inner p2,
+            @TB Outer. @TC Inner p3) { }
+
+    void f1cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.Inner) o;
+        l = (Outer. @TC Inner) o;
+        l = (@TB Outer. @TC Inner) o;
     }
 
-    List<@A Outer.Inner> f2;
-    List<@A Outer.Inner> f2r() { return null; }
-    void f2p(List<@A Outer.Inner> p) { }
-    void f2c(Object o) {
-        Object l = (List<@A Outer.Inner>) o;
+    List<@TB Outer> g1;
+    List<@TB Outer.Inner> g1a;
+    List<Outer. @TC Inner> g1b;
+    List<@TB Outer. @TC Inner> g1c;
+
+    List<@TA Top. @TB Outer> g2;
+    List<@TA Top. @TB Outer.Inner> g2a;
+    List<@TA Top. Outer. @TC Inner> g2b;
+    List<@TA Top. @TB Outer. @TC Inner> g2c;
+
+    List<@TB Outer> g1r() { return null; }
+    List<@TB Outer.Inner> g1ra() { return null; }
+    List<Outer. @TC Inner> g1rb() { return null; }
+    List<@TB Outer. @TC Inner> g1rc() { return null; }
+
+    void g1param(List<@TB Outer> p,
+            List<@TB Outer.Inner> p1,
+            List<Outer. @TC Inner> p2,
+            List<@TB Outer. @TC Inner> p3) { }
+
+    void g1new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.Inner>();
+        l = new @TB HashMap<String, Outer. @TC Inner>();
+        l = new @TB HashMap<String, @TB Outer. Inner>();
+        l = new @TB HashMap<String, @TB Outer. @TC Inner>();
+        l = new @TB HashMap<String, @TA Top. Outer. @TC Inner>();
+        l = new @TB HashMap<String, @TA Top. @TB Outer. Inner>();
+        l = new @TB HashMap<String, @TA Top. @TB Outer. @TC Inner>();
     }
-
-    // OK:
-    @A Outer g1;
-    List<@A Outer> g2;
-    Outer. @A Inner g3;
-    List<Outer. @A Inner> g4;
 }
--- a/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.out	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-CantAnnotateStaticClass.java:22:20: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:23:13: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:24:29: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:29:26: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:30:9: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:31:35: compiler.err.cant.annotate.static.class
-CantAnnotateStaticClass.java:26:29: compiler.err.cant.annotate.static.class
-- compiler.note.unchecked.filename: CantAnnotateStaticClass.java
-- compiler.note.unchecked.recompile
-7 errors
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,207 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8006733 8006775
+ * @summary Ensure behavior for nested types is correct.
+ * @author Werner Dietl
+ * @ignore
+ * @compile/fail/ref=CantAnnotateStaticClass2.out -XDrawDiagnostics CantAnnotateStaticClass2.java
+ */
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.lang.annotation.*;
+
+class Top {
+    @Target(ElementType.TYPE_USE)
+    @interface TA {}
+
+    @Target(ElementType.TYPE_USE)
+    @interface TB {}
+
+    @Target(ElementType.TYPE_USE)
+    @interface TC {}
+
+    static class Outer {
+        class Inner {
+            // Object o1 = Top.this;
+            Object o2 = Outer.this;
+            Object o3 = this;
+        }
+        static class SInner {
+            // Object o1 = Top.this;
+            // Object o2 = Outer.this;
+            Object o3 = this;
+        }
+        interface IInner {
+            // Object o1 = Top.this;
+            // Object o2 = Outer.this;
+            // Object o3 = this;
+        }
+    }
+
+    @TB Outer f1;
+    @TB Outer.Inner f1a;
+    @TB Outer.SInner f2a; // err
+    @TB Outer.IInner f3a; // err
+
+    Outer. @TC Inner f1b;
+    Outer. @TC SInner f2b;
+    Outer. @TC IInner f3b;
+
+    @TB Outer. @TC Inner f1c;
+    @TB Outer. @TC SInner f2c; // err
+    @TB Outer. @TC IInner f3c; // err
+
+    @TA Top. @TB Outer g1; // err
+    @TA Top. @TB Outer.Inner g1a; // err
+    @TA Top. @TB Outer.SInner g2a; // err
+    @TA Top. @TB Outer.IInner g3a; // err
+
+    @TA Top. Outer. @TC Inner g1b; // err
+    @TA Top. Outer. @TC SInner g2b; // err
+    @TA Top. Outer. @TC IInner g3b; // err
+
+    @TA Top. @TB Outer. @TC Inner g1c; // err
+    @TA Top. @TB Outer. @TC SInner g2c; // err
+    @TA Top. @TB Outer. @TC IInner g3c; // err
+
+    @TB Outer f1r() { return null; }
+
+    @TB Outer.Inner f1ra() { return null; }
+    @TB Outer.SInner f2ra() { return null; } // err
+    @TB Outer.IInner f3ra() { return null; } // err
+
+    Outer. @TC Inner f1rb() { return null; }
+    Outer. @TC SInner f2rb() { return null; }
+    Outer. @TC IInner f3rb() { return null; }
+
+    @TB Outer. @TC Inner f1rc() { return null; }
+    @TB Outer. @TC SInner f2rc() { return null; } // err
+    @TB Outer. @TC IInner f3rc() { return null; } // err
+
+    void f1param(@TB Outer p,
+            @TB Outer.Inner p1,
+            Outer. @TC Inner p2,
+            @TB Outer. @TC Inner p3) { }
+    void f2param(@TB Outer p,
+            @TB Outer.SInner p1, // err
+            Outer. @TC SInner p2,
+            @TB Outer. @TC SInner p3) { } // err
+    void f3param(@TB Outer p,
+            @TB Outer.IInner p1, // err
+            Outer. @TC IInner p2,
+            @TB Outer. @TC IInner p3) { } // err
+
+    void f1cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.Inner) o;
+        l = (Outer. @TC Inner) o;
+        l = (@TB Outer. @TC Inner) o;
+    }
+    void f2cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.SInner) o; // err
+        l = (Outer. @TC SInner) o;
+        l = (@TB Outer. @TC SInner) o; // err
+    }
+    void f3cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.IInner) o; // err
+        l = (Outer. @TC IInner) o;
+        l = (@TB Outer. @TC IInner) o; // err
+    }
+
+    List<@TB Outer> h1;
+
+    List<@TB Outer.Inner> h1a;
+    List<@TB Outer.SInner> h2a; // err
+    List<@TB Outer.IInner> h3a; // err
+
+    List<Outer. @TC Inner> h1b;
+    List<Outer. @TC SInner> h2b;
+    List<Outer. @TC IInner> h3b;
+
+    List<@TB Outer. @TC Inner> h1c;
+    List<@TB Outer. @TC SInner> h2c; // err
+    List<@TB Outer. @TC IInner> h3c; // err
+
+    List<@TA Top. @TB Outer> k1; // err
+
+    List<@TA Top. @TB Outer.Inner> k1a; // err
+    List<@TA Top. @TB Outer.SInner> k2a; // err
+    List<@TA Top. @TB Outer.IInner> k3a; // err
+
+    List<@TA Top. Outer. @TC Inner> k1b; // err
+    List<@TA Top. Outer. @TC SInner> k2b; // err
+    List<@TA Top. Outer. @TC IInner> k3b; // err
+
+    List<@TA Top. @TB Outer. @TC Inner> k1c; // err
+    List<@TA Top. @TB Outer. @TC SInner> k2c; // err
+    List<@TA Top. @TB Outer. @TC IInner> k3c; // err
+
+
+    List<@TB Outer> g1r() { return null; }
+
+    List<@TB Outer.Inner> g1ra() { return null; }
+    List<@TB Outer.SInner> g2ra() { return null; } // err
+    List<@TB Outer.IInner> g3ra() { return null; } // err
+
+    List<Outer. @TC Inner> g1rb() { return null; }
+    List<Outer. @TC SInner> g2rb() { return null; }
+    List<Outer. @TC IInner> g3rb() { return null; }
+
+    List<@TB Outer. @TC Inner> g1rc() { return null; }
+    List<@TB Outer. @TC SInner> g2rc() { return null; } // err
+    List<@TB Outer. @TC IInner> g3rc() { return null; } // err
+
+    void g1param(List<@TB Outer> p,
+            List<@TB Outer.Inner> p1,
+            List<Outer. @TC Inner> p2,
+            List<@TB Outer. @TC Inner> p3) { }
+    void g2param(List<@TB Outer> p,
+            List<@TB Outer.SInner> p1, // err
+            List<Outer. @TC SInner> p2,
+            List<@TB Outer. @TC SInner> p3) { } // err
+    void g3param(List<@TB Outer> p,
+            List<@TB Outer.IInner> p1, // err
+            List<Outer. @TC IInner> p2,
+            List<@TB Outer. @TC IInner> p3) { } // err
+
+    void g1new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.Inner>();
+        l = new @TB HashMap<String, Outer. @TC Inner>();
+        l = new @TB HashMap<String, @TB Outer. Inner>();
+        l = new @TB HashMap<String, @TB Outer. @TC Inner>();
+    }
+    void g2new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.SInner>(); // err
+        l = new @TB HashMap<String, Outer. @TC SInner>();
+        l = new @TB HashMap<String, @TB Outer. SInner>(); // err
+        l = new @TB HashMap<String, @TB Outer. @TC SInner>(); // err
+    }
+    void g3new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.IInner>(); // err
+        l = new @TB HashMap<String, Outer. @TC IInner>();
+        l = new @TB HashMap<String, @TB Outer. IInner>(); // err
+        l = new @TB HashMap<String, @TB Outer. @TC IInner>(); // err
+    }
+    void g4new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TA Top. @TB Outer>(); // err
+        l = new @TB ArrayList<@TA Top. @TB Outer.IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. Outer. @TC IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. @TB Outer. IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. @TB Outer. @TC IInner>(); // err
+        l = new @TB HashMap<String, @TA @TB @TC Top. Outer. IInner>(); // err
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,65 @@
+CantAnnotateStaticClass2.java:44:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:45:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:52:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:53:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:55:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:56:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:60:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:61:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:62:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:64:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:65:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:66:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:71:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:72:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:79:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:80:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:87:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:89:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:91:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:93:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:105:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:107:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:112:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:114:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:120:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:121:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:128:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:129:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:131:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:133:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:137:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:138:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:139:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:141:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:149:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:150:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:157:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:158:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:165:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:167:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:169:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:171:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:184:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:186:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:187:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:192:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:194:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:195:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:199:35: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:200:38: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:201:41: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass2.java:202:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass2.java:204:49: compiler.err.cant.type.annotate.scoping: @Top.TA,@Top.TB,@Top.TC
+64 errors
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,207 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8006733 8006775
+ * @summary Ensure behavior for nested types is correct.
+ * @author Werner Dietl
+ * @ignore
+ * @compile/fail/ref=CantAnnotateStaticClass3.out -XDrawDiagnostics CantAnnotateStaticClass3.java
+ */
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.lang.annotation.*;
+
+class Top {
+    @Target(ElementType.TYPE_USE)
+    @interface TA {}
+
+    @Target(ElementType.TYPE_USE)
+    @interface TB {}
+
+    @Target(ElementType.TYPE_USE)
+    @interface TC {}
+
+    interface Outer {
+        class Inner {
+            // Object o1 = Top.this;
+            // Object o2 = Outer.this;
+            Object o3 = this;
+        }
+        static class SInner {
+            // Object o1 = Top.this;
+            // Object o2 = Outer.this;
+            Object o3 = this;
+        }
+        interface IInner {
+            // Object o1 = Top.this;
+            // Object o2 = Outer.this;
+            // Object o3 = this;
+        }
+    }
+
+
+    @TB Outer f1;
+    @TB Outer.Inner f1a; // err
+    @TB Outer.SInner f2a; // err
+    @TB Outer.IInner f3a; // err
+
+    Outer. @TC Inner f1b;
+    Outer. @TC SInner f2b;
+    Outer. @TC IInner f3b;
+
+    @TB Outer. @TC Inner f1c; // err
+    @TB Outer. @TC SInner f2c; // err
+    @TB Outer. @TC IInner f3c; // err
+
+    @TA Top. @TB Outer g1; // err
+    @TA Top. @TB Outer.Inner g1a; // err
+    @TA Top. @TB Outer.SInner g2a; // err
+    @TA Top. @TB Outer.IInner g3a; // err
+
+    @TA Top. Outer. @TC Inner g1b; // err
+    @TA Top. Outer. @TC SInner g2b; // err
+    @TA Top. Outer. @TC IInner g3b; // err
+
+    @TA Top. @TB Outer. @TC Inner g1c; // err
+    @TA Top. @TB Outer. @TC SInner g2c; // err
+    @TA Top. @TB Outer. @TC IInner g3c; // err
+
+    @TB Outer f1r() { return null; }
+
+    @TB Outer.Inner f1ra() { return null; } // err
+    @TB Outer.SInner f2ra() { return null; } // err
+    @TB Outer.IInner f3ra() { return null; } // err
+
+    Outer. @TC Inner f1rb() { return null; }
+    Outer. @TC SInner f2rb() { return null; }
+    Outer. @TC IInner f3rb() { return null; }
+
+    @TB Outer. @TC Inner f1rc() { return null; } // err
+    @TB Outer. @TC SInner f2rc() { return null; } // err
+    @TB Outer. @TC IInner f3rc() { return null; } // err
+
+    void f1param(@TB Outer p,
+            @TB Outer.Inner p1, // err
+            Outer. @TC Inner p2,
+            @TB Outer. @TC Inner p3) { } // err
+    void f2param(@TB Outer p,
+            @TB Outer.SInner p1, // err
+            Outer. @TC SInner p2,
+            @TB Outer. @TC SInner p3) { } // err
+    void f3param(@TB Outer p,
+            @TB Outer.IInner p1, // err
+            Outer. @TC IInner p2,
+            @TB Outer. @TC IInner p3) { } // err
+
+    void f1cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.Inner) o; // err
+        l = (Outer. @TC Inner) o;
+        l = (@TB Outer. @TC Inner) o; // err
+    }
+    void f2cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.SInner) o; // err
+        l = (Outer. @TC SInner) o;
+        l = (@TB Outer. @TC SInner) o; // err
+    }
+    void f3cast(Object o) {
+        Object l;
+        l = (@TB Outer) o;
+        l = (@TB Outer.IInner) o; // err
+        l = (Outer. @TC IInner) o;
+        l = (@TB Outer. @TC IInner) o; // err
+    }
+
+    List<@TB Outer> h1;
+
+    List<@TB Outer.Inner> h1a; // err
+    List<@TB Outer.SInner> h2a; // err
+    List<@TB Outer.IInner> h3a; // err
+
+    List<Outer. @TC Inner> h1b;
+    List<Outer. @TC SInner> h2b;
+    List<Outer. @TC IInner> h3b;
+
+    List<@TB Outer. @TC Inner> h1c; // err
+    List<@TB Outer. @TC SInner> h2c; // err
+    List<@TB Outer. @TC IInner> h3c; // err
+
+    List<@TA Top. @TB Outer> k1; // err
+
+    List<@TA Top. @TB Outer.Inner> k1a; // err
+    List<@TA Top. @TB Outer.SInner> k2a; // err
+    List<@TA Top. @TB Outer.IInner> k3a; // err
+
+    List<@TA Top. Outer. @TC Inner> k1b; // err
+    List<@TA Top. Outer. @TC SInner> k2b; // err
+    List<@TA Top. Outer. @TC IInner> k3b; // err
+
+    List<@TA Top. @TB Outer. @TC Inner> k1c; // err
+    List<@TA Top. @TB Outer. @TC SInner> k2c; // err
+    List<@TA Top. @TB Outer. @TC IInner> k3c; // err
+
+
+    List<@TB Outer> g1r() { return null; }
+
+    List<@TB Outer.Inner> g1ra() { return null; } // err
+    List<@TB Outer.SInner> g2ra() { return null; } // err
+    List<@TB Outer.IInner> g3ra() { return null; } // err
+
+    List<Outer. @TC Inner> g1rb() { return null; }
+    List<Outer. @TC SInner> g2rb() { return null; }
+    List<Outer. @TC IInner> g3rb() { return null; }
+
+    List<@TB Outer. @TC Inner> g1rc() { return null; } // err
+    List<@TB Outer. @TC SInner> g2rc() { return null; } // err
+    List<@TB Outer. @TC IInner> g3rc() { return null; } // err
+
+    void g1param(List<@TB Outer> p,
+            List<@TB Outer.Inner> p1, // err
+            List<Outer. @TC Inner> p2,
+            List<@TB Outer. @TC Inner> p3) { } // err
+    void g2param(List<@TB Outer> p,
+            List<@TB Outer.SInner> p1, // err
+            List<Outer. @TC SInner> p2,
+            List<@TB Outer. @TC SInner> p3) { } // err
+    void g3param(List<@TB Outer> p,
+            List<@TB Outer.IInner> p1, // err
+            List<Outer. @TC IInner> p2,
+            List<@TB Outer. @TC IInner> p3) { } // err
+
+    void g1new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.Inner>(); // err
+        l = new @TB HashMap<String, Outer. @TC Inner>();
+        l = new @TB HashMap<String, @TB Outer. Inner>(); // err
+        l = new @TB HashMap<String, @TB Outer. @TC Inner>(); // err
+    }
+    void g2new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.SInner>(); // err
+        l = new @TB HashMap<String, Outer. @TC SInner>();
+        l = new @TB HashMap<String, @TB Outer. SInner>(); // err
+        l = new @TB HashMap<String, @TB Outer. @TC SInner>(); // err
+    }
+    void g3new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TB Outer>();
+        l = new @TB ArrayList<@TB Outer.IInner>(); // err
+        l = new @TB HashMap<String, Outer. @TC IInner>();
+        l = new @TB HashMap<String, @TB Outer. IInner>(); // err
+        l = new @TB HashMap<String, @TB Outer. @TC IInner>(); // err
+    }
+    void g4new(Object o) {
+        Object l;
+        l = new @TB ArrayList<@TA Top. @TB Outer>(); // err
+        l = new @TB ArrayList<@TA Top. @TB Outer.IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. Outer. @TC IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. @TB Outer. IInner>(); // err
+        l = new @TB HashMap<String, @TA Top. @TB Outer. @TC IInner>(); // err
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,83 @@
+CantAnnotateStaticClass3.java:44:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:45:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:46:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:52:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:53:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:54:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:56:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:59:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:61:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:62:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:63:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:65:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:66:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:67:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:71:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:72:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:73:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:79:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:80:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:81:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:84:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:86:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:88:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:90:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:92:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:94:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:59:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:67:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:99:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:101:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:106:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:108:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:113:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:115:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:120:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:121:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:122:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:128:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:129:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:130:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:132:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:136:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:138:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:139:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:140:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:144:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:149:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:150:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:151:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:157:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:158:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:159:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:162:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:164:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:166:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:168:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:170:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:172:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:177:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:179:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:180:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:185:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:187:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:188:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:193:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:195:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:196:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:200:35: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:201:38: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:202:41: compiler.err.cant.type.annotate.scoping.1: @Top.TA
+CantAnnotateStaticClass3.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+CantAnnotateStaticClass3.java:204:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
+82 errors
\ No newline at end of file
--- a/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.java	Tue Oct 15 15:57:13 2013 -0700
@@ -5,8 +5,11 @@
  * @author Mahmood Ali
  * @compile/fail/ref=IncompleteArray.out -XDrawDiagnostics IncompleteArray.java
  */
+import java.lang.annotation.*;
+
 class IncompleteArray {
   int @A [] @A var;
 }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,2 @@
-IncompleteArray.java:9:13: compiler.err.illegal.start.of.type
+IncompleteArray.java:11:13: compiler.err.illegal.start.of.type
 1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.java	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-/*
- * @test /nodynamiccopyright/
- * @bug 6843077 8006775
- * @summary test incomplete vararg declaration
- * @author Mahmood Ali
- * @compile/fail/ref=IncompleteVararg.out -XDrawDiagnostics IncompleteVararg.java
- */
-class IncompleteArray {
-  // the last variable may be vararg
-  void method(int @A test) { }
-}
-
-@interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.out	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-IncompleteVararg.java:10:19: compiler.err.illegal.start.of.type
-1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.java	Tue Oct 15 15:57:13 2013 -0700
@@ -5,9 +5,12 @@
  * @author Mahmood Ali
  * @compile/fail/ref=IndexArray.out -XDrawDiagnostics IndexArray.java
  */
+import java.lang.annotation.*;
+
 class IndexArray {
   int[] var;
   int a = var @A [1];
 }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,2 @@
-IndexArray.java:10:15: compiler.err.illegal.start.of.expr
+IndexArray.java:12:15: compiler.err.illegal.start.of.expr
 1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/LintCast.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/LintCast.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,11 +1,11 @@
 LintCast.java:15:21: compiler.warn.redundant.cast: java.lang.String
 LintCast.java:21:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
-LintCast.java:27:20: compiler.warn.redundant.cast: int @A []
+LintCast.java:27:20: compiler.warn.redundant.cast: int[]
 LintCast.java:39:24: compiler.warn.redundant.cast: java.lang.String
 LintCast.java:40:26: compiler.warn.redundant.cast: java.lang.String
-LintCast.java:45:23: compiler.warn.redundant.cast: java.lang.Object @A []
+LintCast.java:45:23: compiler.warn.redundant.cast: java.lang.Object[]
 LintCast.java:49:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
-LintCast.java:53:27: compiler.warn.redundant.cast: java.util.List<@A java.lang.String>
+LintCast.java:53:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
 LintCast.java:57:21: compiler.warn.redundant.cast: java.lang.Object
 LintCast.java:61:27: compiler.warn.redundant.cast: LintCast.Outer.Inner
 10 warnings
\ No newline at end of file
--- a/test/tools/javac/annotations/typeAnnotations/failures/OldArray.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/OldArray.java	Tue Oct 15 15:57:13 2013 -0700
@@ -1,35 +1,16 @@
 /*
- * Copyright (c) 2008, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
+ * @test /nodynamiccopyright/
  * @test
  * @bug 6843077 8006775
  * @summary test old array syntax
  * @author Mahmood Ali
- * @compile/fail -XDrawDiagnostics OldArray.java
+ * @compile/fail/ref=OldArray.out -XDrawDiagnostics OldArray.java
  */
+import java.lang.annotation.*;
+
 class OldArray {
   String [@A]  s() { return null; }
 }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/OldArray.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,10 @@
+OldArray.java:12:11: compiler.err.expected: ']'
+OldArray.java:12:13: compiler.err.expected: token.identifier
+OldArray.java:12:14: compiler.err.expected: ';'
+OldArray.java:12:17: compiler.err.illegal.start.of.type
+OldArray.java:12:18: compiler.err.expected: token.identifier
+OldArray.java:12:19: compiler.err.expected: ';'
+OldArray.java:12:22: compiler.err.illegal.start.of.type
+OldArray.java:12:28: compiler.err.expected: token.identifier
+OldArray.java:13:1: compiler.err.expected3: class, interface, enum
+9 errors
--- a/test/tools/javac/annotations/typeAnnotations/failures/Scopes.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/Scopes.java	Tue Oct 15 15:57:13 2013 -0700
@@ -1,17 +1,16 @@
 /*
  * @test /nodynamiccopyright/
  * @bug 6843077 8006775
- * @summary check that A is accessible in the class type parameters
+ * @summary Unqualified inner type annotation not in scope.
  * @author Mahmood Ali
  * @compile/fail/ref=Scopes.out -XDrawDiagnostics Scopes.java
  */
-class Scopes<T extends @UniqueInner Object> {
-  // UniqueInner is not visible in the type parameters.
-  // One has to use Scopes.UniqueInner.
-  // Annotations with the default @Target are not allowed there,
-  // so we also get the second error about the invalid location.
-  // Adding the target here doesn't matter, as we don't resolve
-  // the annotation type.
-  // @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
-  @interface UniqueInner { };
+import java.lang.annotation.*;
+
+@InnerTA
+class Scopes<@InnerTA T extends @InnerTA Object> {
+    // The simple name TA is not in scope on header of class.
+    // One has to use @Scopes.TA.
+    @Target(ElementType.TYPE_USE)
+    @interface InnerTA { };
 }
--- a/test/tools/javac/annotations/typeAnnotations/failures/Scopes.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/Scopes.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,3 +1,4 @@
-Scopes.java:8:25: compiler.err.cant.resolve: kindname.class, UniqueInner, , 
-Scopes.java:8:24: compiler.err.annotation.type.not.applicable
-2 errors
+Scopes.java:10:2: compiler.err.cant.resolve: kindname.class, InnerTA, , 
+Scopes.java:11:34: compiler.err.cant.resolve: kindname.class, InnerTA, , 
+Scopes.java:11:15: compiler.err.cant.resolve: kindname.class, InnerTA, , 
+3 errors
--- a/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.java	Tue Oct 15 15:57:13 2013 -0700
@@ -5,9 +5,23 @@
  * @author Mahmood Ali
  * @compile/fail/ref=StaticFields.out -XDrawDiagnostics StaticFields.java
  */
+import java.lang.annotation.*;
+
 class C {
-  int f;
+  static int f;
+  // static block
+  static {
+    @A C.f = 1;
+  }
+  // static ref
   int a = @A C.f;
+  // static method
+  static int f() { return @A C.f; }
+  // main
+  public static void main(String... args) {
+    int a = @A C.f;
+  }
 }
 
+@Target(ElementType.TYPE_USE)
 @interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.out	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.out	Tue Oct 15 15:57:13 2013 -0700
@@ -1,2 +1,5 @@
-StaticFields.java:10:17: compiler.err.illegal.start.of.expr
-1 error
+StaticFields.java:14:11: compiler.err.expected: token.identifier
+StaticFields.java:17:17: compiler.err.illegal.start.of.expr
+StaticFields.java:19:33: compiler.err.illegal.start.of.expr
+StaticFields.java:22:19: compiler.err.illegal.start.of.expr
+4 errors
\ No newline at end of file
--- a/test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.java	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-/*
- * @test /nodynamiccopyright/
- * @bug 6843077 8006775
- * @summary static methods don't have receivers
- * @author Mahmood Ali
- * @compile/fail/ref=StaticMethods.out -XDrawDiagnostics StaticMethods.java
- */
-class StaticMethods {
-  static void main(StaticMethods this) { }
-}
-
-@interface A { }
--- a/test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.out	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-StaticMethods.java:9:34: compiler.err.non-static.cant.be.ref: kindname.variable, this
-1 error
--- a/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableCycleTest.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableCycleTest.java	Tue Oct 15 15:57:13 2013 -0700
@@ -35,10 +35,12 @@
 
 class TypeVariableCycleTest<CTV> {
     <MTV extends  @TA CTV> MTV cast(CTV p) {
-        return (@TA MTV) p;
+        return (@TB MTV) p;
     }
 }
 
-@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@Target(ElementType.TYPE_USE)
 @interface TA {}
 
+@Target(ElementType.TYPE_USE)
+@interface TB {}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 1234567
+ * @summary A missing annotation type in a type variable bound
+ *     should result in the same errors with and without an
+ *     annotation processor.
+ * @author Werner Dietl
+ *
+ * @compile DummyProcessor.java
+ * @compile/fail/ref=TypeVariableMissingTA.out -XDrawDiagnostics TypeVariableMissingTA.java
+ * @compile/fail/ref=TypeVariableMissingTA.out -XDrawDiagnostics -cp . -processor DummyProcessor TypeVariableMissingTA.java
+ */
+
+import java.lang.annotation.*;
+
+class TypeVariableMissingTA<T extends @MISSING Object> {}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.out	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,2 @@
+TypeVariableMissingTA.java:39:40: compiler.err.cant.resolve: kindname.class, MISSING, , 
+1 error
\ No newline at end of file
--- a/test/tools/javac/diags/examples/CantAnnotateNestedType.java	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2012, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-// key: compiler.err.cant.annotate.nested.type
-
-import java.lang.annotation.*;
-
-class CantAnnotateStaticClass {
-    @Target(ElementType.TYPE_USE)
-    @interface A {}
-
-    interface Outer {
-        interface Inner {}
-    }
-
-    // Error:
-    @A Outer.Inner f;
-
-    // OK:
-    @A Outer g;
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/diags/examples/CantAnnotateScoping.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2012, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// key: compiler.err.cant.type.annotate.scoping
+
+import java.lang.annotation.*;
+
+class CantAnnotateScoping {
+    @Target(ElementType.TYPE_USE)
+    @interface TA {}
+    @Target(ElementType.TYPE_USE)
+    @interface TB {}
+
+    interface Outer {
+        interface Inner {}
+    }
+
+    // Error:
+    @TA @TB Outer.Inner f;
+
+    // OK:
+    @TA @TB Outer g;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/diags/examples/CantAnnotateScoping1.java	Tue Oct 15 15:57:13 2013 -0700
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2012, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// key: compiler.err.cant.type.annotate.scoping.1
+
+import java.lang.annotation.*;
+
+class CantAnnotateNestedType {
+    @Target(ElementType.TYPE_USE)
+    @interface TA {}
+
+    interface Outer {
+        interface Inner {}
+    }
+
+    // Error:
+    @TA Outer.Inner f;
+
+    // OK:
+    @TA Outer g;
+}
--- a/test/tools/javac/diags/examples/CantAnnotateStaticClass.java	Tue Oct 15 22:15:35 2013 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2012, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-// key: compiler.err.cant.annotate.static.class
-
-import java.lang.annotation.*;
-
-class CantAnnotateStaticClass {
-    @Target(ElementType.TYPE_USE)
-    @interface A {}
-
-    static class Outer {
-        class Inner {}
-    }
-
-    // Error:
-    @A Outer.Inner f;
-
-    // OK:
-    @A Outer g;
-}
--- a/test/tools/javac/lib/DPrinter.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/lib/DPrinter.java	Tue Oct 15 15:57:13 2013 -0700
@@ -946,8 +946,8 @@
      */
     public class TypeVisitor implements Type.Visitor<Void,Void> {
         public Void visitAnnotatedType(AnnotatedType type, Void ignore) {
-            printList("typeAnnotations", type.typeAnnotations);
-            printType("underlyingType", type.underlyingType, Details.FULL);
+            printList("typeAnnotations", type.getAnnotationMirrors());
+            printType("underlyingType", type.unannotatedType(), Details.FULL);
             return visitType(type, null);
         }
 
--- a/test/tools/javac/processing/model/type/BasicAnnoTests.java	Tue Oct 15 22:15:35 2013 +0200
+++ b/test/tools/javac/processing/model/type/BasicAnnoTests.java	Tue Oct 15 15:57:13 2013 -0700
@@ -26,6 +26,7 @@
  * @bug     1234567
  * @summary Annotations on types
  * @library /tools/javac/lib
+ * @ignore
  * @build JavacTestingAbstractProcessor DPrinter BasicAnnoTests
  * @compile/process -processor BasicAnnoTests -proc:only BasicAnnoTests.java
  */