changeset 3343:1472e30d4a7b

8040327: Eliminate AnnotatedType Summary: Replace AnnotatedType with type annotations being stored in the Type class as metadata Reviewed-by: jjg, jfranck, wmdietl, jlahoda
author emc
date Fri, 09 May 2014 09:28:47 -0400
parents 228659ae84f3
children e5d0d7510671
files 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/Symbol.java src/share/classes/com/sun/tools/javac/code/Type.java src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.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/Attr.java src/share/classes/com/sun/tools/javac/comp/Check.java src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java src/share/classes/com/sun/tools/javac/comp/Infer.java src/share/classes/com/sun/tools/javac/comp/Lower.java src/share/classes/com/sun/tools/javac/comp/MemberEnter.java src/share/classes/com/sun/tools/javac/comp/Resolve.java src/share/classes/com/sun/tools/javac/jvm/ClassReader.java src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java src/share/classes/com/sun/tools/javac/jvm/Code.java src/share/classes/com/sun/tools/javac/jvm/Gen.java src/share/classes/com/sun/tools/javac/jvm/JNIWriter.java src/share/classes/com/sun/tools/javac/jvm/Pool.java src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java src/share/classes/com/sun/tools/javac/model/JavacTypes.java src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java src/share/classes/com/sun/tools/javadoc/AnnotatedTypeImpl.java src/share/classes/com/sun/tools/javadoc/TypeMaker.java test/tools/javac/annotations/typeAnnotations/referenceinfos/Driver.java test/tools/javac/types/TypeHarness.java
diffstat 27 files changed, 582 insertions(+), 491 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/code/Attribute.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Attribute.java	Fri May 09 09:28:47 2014 -0400
@@ -118,7 +118,8 @@
                 : types.erasure(type);
             return new Type.ClassType(types.syms.classType.getEnclosingType(),
                                       List.of(arg),
-                                      types.syms.classType.tsym);
+                                      types.syms.classType.tsym,
+                                      Type.noAnnotations);
         }
         public String toString() {
             return classType + ".class";
--- a/src/share/classes/com/sun/tools/javac/code/Printer.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Printer.java	Fri May 09 09:28:47 2014 -0400
@@ -28,7 +28,6 @@
 import java.util.Locale;
 
 import com.sun.tools.javac.api.Messages;
-import com.sun.tools.javac.code.Type.AnnotatedType;
 import com.sun.tools.javac.code.Type.ArrayType;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
@@ -150,14 +149,16 @@
     @Override
     public String visitCapturedType(CapturedType t, Locale locale) {
         if (seenCaptured.contains(t))
-            return localize(locale, "compiler.misc.type.captureof.1",
-                capturedVarId(t, locale));
+            return printAnnotations(t) +
+                localize(locale, "compiler.misc.type.captureof.1",
+                         capturedVarId(t, locale));
         else {
             try {
                 seenCaptured = seenCaptured.prepend(t);
-                return localize(locale, "compiler.misc.type.captureof",
-                    capturedVarId(t, locale),
-                    visit(t.wildcard, locale));
+                return printAnnotations(t) +
+                    localize(locale, "compiler.misc.type.captureof",
+                             capturedVarId(t, locale),
+                             visit(t.wildcard, locale));
             }
             finally {
                 seenCaptured = seenCaptured.tail;
@@ -167,15 +168,16 @@
 
     @Override
     public String visitForAll(ForAll t, Locale locale) {
-        return "<" + visitTypes(t.tvars, locale) + ">" + visit(t.qtype, locale);
+        return printAnnotations(t) + "<" + visitTypes(t.tvars, locale) +
+            ">" + visit(t.qtype, locale);
     }
 
     @Override
     public String visitUndetVar(UndetVar t, Locale locale) {
         if (t.inst != null) {
-            return visit(t.inst, locale);
+            return printAnnotations(t) + visit(t.inst, locale);
         } else {
-            return visit(t.qtype, locale) + "?";
+            return printAnnotations(t) + visit(t.qtype, locale) + "?";
         }
     }
 
@@ -187,25 +189,34 @@
         return res.toString();
     }
 
-    void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
+    private String printAnnotations(Type t) {
+        return printAnnotations(t, false);
+    }
+
+    private String printAnnotations(Type t, boolean prefix) {
+        StringBuilder sb = new StringBuilder();
+        List<Attribute.TypeCompound> annos = t.getAnnotationMirrors();
+        if (!annos.isEmpty()) {
+            if (prefix) sb.append(' ');
+            sb.append(annos);
+            sb.append(' ');
+        }
+        return sb.toString();
+    }
+
+    private void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
         Type arrel = t;
         while (arrel.hasTag(TypeTag.ARRAY)) {
-            arrel = arrel.unannotatedType();
             arrel = ((ArrayType) arrel).elemtype;
         }
         sb.append(visit(arrel, locale));
     }
 
-    void printBrackets(Type t, StringBuilder sb, Locale locale) {
+    private void printBrackets(Type t, StringBuilder sb, Locale locale) {
         Type arrel = t;
         while (arrel.hasTag(TypeTag.ARRAY)) {
-            if (arrel.isAnnotated()) {
-                sb.append(' ');
-                sb.append(arrel.getAnnotationMirrors());
-                sb.append(' ');
-            }
+            sb.append(printAnnotations(arrel, true));
             sb.append("[]");
-            arrel = arrel.unannotatedType();
             arrel = ((ArrayType) arrel).elemtype;
         }
     }
@@ -216,8 +227,10 @@
         if (t.getEnclosingType().hasTag(CLASS) && t.tsym.owner.kind == Kinds.TYP) {
             buf.append(visit(t.getEnclosingType(), locale));
             buf.append('.');
+            buf.append(printAnnotations(t));
             buf.append(className(t, false, locale));
         } else {
+            buf.append(printAnnotations(t));
             buf.append(className(t, true, locale));
         }
         if (t.getTypeArguments().nonEmpty()) {
@@ -230,7 +243,8 @@
 
     @Override
     public String visitMethodType(MethodType t, Locale locale) {
-        return "(" + printMethodArgs(t.argtypes, false, locale) + ")" + visit(t.restype, locale);
+        return "(" + printMethodArgs(t.argtypes, false, locale) + ")" +
+            visit(t.restype, locale);
     }
 
     @Override
@@ -243,6 +257,7 @@
         StringBuilder s = new StringBuilder();
         s.append(t.kind);
         if (t.kind != UNBOUND) {
+            s.append(printAnnotations(t));
             s.append(visit(t.type, locale));
         }
         return s.toString();
@@ -258,28 +273,6 @@
         return visitType(t, locale);
     }
 
-    @Override
-    public String visitAnnotatedType(AnnotatedType t, Locale locale) {
-        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.unannotatedType().hasTag(TypeTag.CLASS) &&
-                    t.unannotatedType().getEnclosingType() != Type.noType) {
-                return visit(t.unannotatedType().getEnclosingType(), locale) +
-                        ". " +
-                        t.getAnnotationMirrors() +
-                        " " + className((ClassType)t.unannotatedType(), false, locale);
-            } else {
-                return t.getAnnotationMirrors() + " " + visit(t.unannotatedType(), locale);
-            }
-        } else {
-            return visit(t.unannotatedType(), locale);
-        }
-    }
-
     public String visitType(Type t, Locale locale) {
         String s = (t.tsym == null || t.tsym.name == null)
                 ? localize(locale, "compiler.misc.type.none")
@@ -345,8 +338,8 @@
                 args = args.tail;
                 buf.append(',');
             }
-            if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
-                buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
+            if (args.head.hasTag(TypeTag.ARRAY)) {
+                buf.append(visit(((ArrayType) args.head).elemtype, locale));
                 if (args.head.getAnnotationMirrors().nonEmpty()) {
                     buf.append(' ');
                     buf.append(args.head.getAnnotationMirrors());
--- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Fri May 09 09:28:47 2014 -0400
@@ -956,7 +956,7 @@
             this(
                 flags,
                 name,
-                new ClassType(Type.noType, null, null),
+                new ClassType(Type.noType, null, null, Type.noAnnotations),
                 owner);
             this.type.tsym = this;
         }
@@ -992,7 +992,8 @@
         public Type erasure(Types types) {
             if (erasure_field == null)
                 erasure_field = new ClassType(types.erasure(type.getEnclosingType()),
-                                              List.<Type>nil(), this);
+                                              List.<Type>nil(), this,
+                                              type.getAnnotationMirrors());
             return erasure_field;
         }
 
--- a/src/share/classes/com/sun/tools/javac/code/Type.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Type.java	Fri May 09 09:28:47 2014 -0400
@@ -80,6 +80,9 @@
     /** Constant type: special type to be used for marking stuck trees. */
     public static final JCNoType stuckType = new JCNoType();
 
+    public static final List<Attribute.TypeCompound> noAnnotations =
+        List.nil();
+
     /** If this switch is turned on, the names of type variables
      *  and anonymous classes are printed with hashcodes appended.
      */
@@ -89,6 +92,10 @@
      */
     public TypeSymbol tsym;
 
+    /** The type annotations on this type.
+     */
+    protected final List<Attribute.TypeCompound> annos;
+
     /**
      * Checks if the current type tag is equal to the given tag.
      * @return true if tag is equal to the current type tag.
@@ -173,10 +180,15 @@
 
     public <R,S> R accept(Type.Visitor<R,S> v, S s) { return v.visitType(this, s); }
 
-    /** Define a type given its tag and type symbol
+    /** Define a type given its tag, type symbol, and type annotations
      */
-    public Type(TypeSymbol tsym) {
+    public Type(TypeSymbol tsym, List<Attribute.TypeCompound> annos) {
+        if(annos == null) {
+            Assert.error("Attempting to create type " + tsym + " with null type annotations");
+        }
+
         this.tsym = tsym;
+        this.annos = annos;
     }
 
     /** An abstract class for mappings from types to types
@@ -225,25 +237,15 @@
         return this;
     }
 
-    public Type annotatedType(List<Attribute.TypeCompound> annos) {
-        return new AnnotatedType(annos, this);
-    }
+    public abstract Type annotatedType(List<Attribute.TypeCompound> annos);
 
     public boolean isAnnotated() {
-        return false;
-    }
-
-    /**
-     * If this is an annotated type, return the underlying type.
-     * Otherwise, return the type itself.
-     */
-    public Type unannotatedType() {
-        return this;
+        return !annos.isEmpty();
     }
 
     @Override
     public List<Attribute.TypeCompound> getAnnotationMirrors() {
-        return List.nil();
+        return annos;
     }
 
 
@@ -272,16 +274,35 @@
         return ts;
     }
 
+    protected void appendAnnotationsString(StringBuilder sb,
+                                         boolean prefix) {
+        if (isAnnotated()) {
+            if (prefix) {
+                sb.append(" ");
+            }
+            sb.append(annos);
+            sb.append(" ");
+        }
+    }
+
+    protected void appendAnnotationsString(StringBuilder sb) {
+        appendAnnotationsString(sb, false);
+    }
+
     /** The Java source which this type represents.
      */
     public String toString() {
-        String s = (tsym == null || tsym.name == null)
-            ? "<none>"
-            : tsym.name.toString();
+        StringBuilder sb = new StringBuilder();
+        appendAnnotationsString(sb);
+        if (tsym == null || tsym.name == null) {
+            sb.append("<none>");
+        } else {
+            sb.append(tsym.name);
+        }
         if (moreInfo && hasTag(TYPEVAR)) {
-            s = s + hashCode();
+            sb.append(hashCode());
         }
-        return s;
+        return sb.toString();
     }
 
     /**
@@ -333,8 +354,8 @@
             args = args.tail;
             buf.append(',');
         }
-        if (args.head.unannotatedType().hasTag(ARRAY)) {
-            buf.append(((ArrayType)args.head.unannotatedType()).elemtype);
+        if (args.head.hasTag(ARRAY)) {
+            buf.append(((ArrayType)args.head).elemtype);
             if (args.head.getAnnotationMirrors().nonEmpty()) {
                 buf.append(args.head.getAnnotationMirrors());
             }
@@ -486,12 +507,22 @@
         TypeTag tag;
 
         public JCPrimitiveType(TypeTag tag, TypeSymbol tsym) {
-            super(tsym);
+            this(tag, tsym, noAnnotations);
+        }
+
+        public JCPrimitiveType(TypeTag tag, TypeSymbol tsym,
+                               List<Attribute.TypeCompound> annos) {
+            super(tsym, annos);
             this.tag = tag;
             Assert.check(tag.isPrimitive);
         }
 
         @Override
+        public Type annotatedType(List<Attribute.TypeCompound> annos) {
+            return new JCPrimitiveType(tag, tsym, annos);
+        }
+
+        @Override
         public boolean isNumeric() {
             return tag != BOOLEAN;
         }
@@ -517,7 +548,7 @@
         @Override
         public Type constType(Object constValue) {
             final Object value = constValue;
-            return new JCPrimitiveType(tag, tsym) {
+            return new JCPrimitiveType(tag, tsym, annos) {
                     @Override
                     public Object constValue() {
                         return value;
@@ -601,17 +632,35 @@
         }
 
         public WildcardType(Type type, BoundKind kind, TypeSymbol tsym) {
-            super(tsym);
+            this(type, kind, tsym, null, noAnnotations);
+        }
+
+        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym,
+                            List<Attribute.TypeCompound> annos) {
+            this(type, kind, tsym, null, annos);
+        }
+
+        public WildcardType(WildcardType t, TypeVar bound,
+                            List<Attribute.TypeCompound> annos) {
+            this(t.type, t.kind, t.tsym, bound, annos);
+        }
+
+        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym,
+                            TypeVar bound) {
+            this(type, kind, tsym, noAnnotations);
+        }
+
+        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym,
+                            TypeVar bound, List<Attribute.TypeCompound> annos) {
+            super(tsym, annos);
             this.type = Assert.checkNonNull(type);
             this.kind = kind;
-        }
-        public WildcardType(WildcardType t, TypeVar bound) {
-            this(t.type, t.kind, t.tsym, bound);
+            this.bound = bound;
         }
 
-        public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, TypeVar bound) {
-            this(type, kind, tsym);
-            this.bound = bound;
+        @Override
+        public WildcardType annotatedType(List<Attribute.TypeCompound> annos) {
+            return new WildcardType(type, kind, tsym, bound, annos);
         }
 
         @Override
@@ -658,6 +707,7 @@
         boolean isPrintingBound = false;
         public String toString() {
             StringBuilder s = new StringBuilder();
+            appendAnnotationsString(s);
             s.append(kind.toString());
             if (kind != UNBOUND)
                 s.append(type);
@@ -679,7 +729,7 @@
             if (t == type)
                 return this;
             else
-                return new WildcardType(t, kind, tsym, bound);
+                return new WildcardType(t, kind, tsym, bound, annos);
         }
 
         public Type getExtendsBound() {
@@ -736,7 +786,12 @@
         public List<Type> all_interfaces_field;
 
         public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym) {
-            super(tsym);
+            this(outer, typarams, tsym, noAnnotations);
+        }
+
+        public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym,
+                         List<Attribute.TypeCompound> annos) {
+            super(tsym, annos);
             this.outer_field = outer;
             this.typarams_field = typarams;
             this.allparams_field = null;
@@ -754,6 +809,15 @@
         }
 
         @Override
+        public ClassType annotatedType(List<Attribute.TypeCompound> annos) {
+            final ClassType out = new ClassType(outer_field, typarams_field, tsym, annos);
+            out.allparams_field = allparams_field;
+            out.supertype_field = supertype_field;
+            out.interfaces_field = interfaces_field;
+            return out;
+        }
+
+        @Override
         public TypeTag getTag() {
             return CLASS;
         }
@@ -765,7 +829,7 @@
 
         public Type constType(Object constValue) {
             final Object value = constValue;
-            return new ClassType(getEnclosingType(), typarams_field, tsym) {
+            return new ClassType(getEnclosingType(), typarams_field, tsym, annos) {
                     @Override
                     public Object constValue() {
                         return value;
@@ -781,6 +845,7 @@
          */
         public String toString() {
             StringBuilder buf = new StringBuilder();
+            appendAnnotationsString(buf);
             if (getEnclosingType().hasTag(CLASS) && tsym.owner.kind == TYP) {
                 buf.append(getEnclosingType().toString());
                 buf.append(".");
@@ -806,7 +871,7 @@
                     return s.toString();
                 } else if (sym.name.isEmpty()) {
                     String s;
-                    ClassType norm = (ClassType) tsym.type.unannotatedType();
+                    ClassType norm = (ClassType) tsym.type;
                     if (norm == null) {
                         s = Log.getLocalizedString("anonymous.class", (Object)null);
                     } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) {
@@ -858,7 +923,7 @@
             return
                 getEnclosingType().isErroneous() ||
                 isErroneous(getTypeArguments()) ||
-                this != tsym.type.unannotatedType() && tsym.type.isErroneous();
+                this != tsym.type && tsym.type.isErroneous();
         }
 
         public boolean isParameterized() {
@@ -897,7 +962,7 @@
             List<Type> typarams = getTypeArguments();
             List<Type> typarams1 = map(typarams, f);
             if (outer1 == outer && typarams1 == typarams) return this;
-            else return new ClassType(outer1, typarams1, tsym);
+            else return new ClassType(outer1, typarams1, tsym, annos);
         }
 
         public boolean contains(Type elem) {
@@ -924,7 +989,12 @@
 
     public static class ErasedClassType extends ClassType {
         public ErasedClassType(Type outer, TypeSymbol tsym) {
-            super(outer, List.<Type>nil(), tsym);
+            this(outer, tsym, noAnnotations);
+        }
+
+        public ErasedClassType(Type outer, TypeSymbol tsym,
+                               List<Attribute.TypeCompound> annos) {
+            super(outer, List.<Type>nil(), tsym, annos);
         }
 
         @Override
@@ -938,7 +1008,9 @@
         final List<? extends Type> alternatives_field;
 
         public UnionClassType(ClassType ct, List<? extends Type> alternatives) {
-            super(ct.outer_field, ct.typarams_field, ct.tsym);
+            // Presently no way to refer to this type directly, so we
+            // cannot put annotations directly on it.
+            super(ct.outer_field, ct.typarams_field, ct.tsym, noAnnotations);
             allparams_field = ct.allparams_field;
             supertype_field = ct.supertype_field;
             interfaces_field = ct.interfaces_field;
@@ -971,7 +1043,9 @@
         public boolean allInterfaces;
 
         public IntersectionClassType(List<Type> bounds, ClassSymbol csym, boolean allInterfaces) {
-            super(Type.noType, List.<Type>nil(), csym);
+            // Presently no way to refer to this type directly, so we
+            // cannot put annotations directly on it.
+            super(Type.noType, List.<Type>nil(), csym, noAnnotations);
             this.allInterfaces = allInterfaces;
             Assert.check((csym.flags() & COMPOUND) != 0);
             supertype_field = bounds.head;
@@ -1011,11 +1085,21 @@
         public Type elemtype;
 
         public ArrayType(Type elemtype, TypeSymbol arrayClass) {
-            super(arrayClass);
+            this(elemtype, arrayClass, noAnnotations);
+        }
+
+        public ArrayType(Type elemtype, TypeSymbol arrayClass,
+                         List<Attribute.TypeCompound> annos) {
+            super(arrayClass, annos);
             this.elemtype = elemtype;
         }
 
         @Override
+        public ArrayType annotatedType(List<Attribute.TypeCompound> annos) {
+            return new ArrayType(elemtype, tsym, annos);
+        }
+
+        @Override
         public TypeTag getTag() {
             return ARRAY;
         }
@@ -1025,7 +1109,11 @@
         }
 
         public String toString() {
-            return elemtype + "[]";
+            StringBuilder sb = new StringBuilder();
+            sb.append(elemtype);
+            appendAnnotationsString(sb, true);
+            sb.append("[]");
+            return sb.toString();
         }
 
         public boolean equals(Object obj) {
@@ -1068,7 +1156,7 @@
         }
 
         public ArrayType makeVarargs() {
-            return new ArrayType(elemtype, tsym) {
+            return new ArrayType(elemtype, tsym, annos) {
                 @Override
                 public boolean isVarargs() {
                     return true;
@@ -1079,7 +1167,7 @@
         public Type map(Mapping f) {
             Type elemtype1 = f.apply(elemtype);
             if (elemtype1 == elemtype) return this;
-            else return new ArrayType(elemtype1, tsym);
+            else return new ArrayType(elemtype1, tsym, annos);
         }
 
         public boolean contains(Type elem) {
@@ -1117,13 +1205,20 @@
                           Type restype,
                           List<Type> thrown,
                           TypeSymbol methodClass) {
-            super(methodClass);
+            // Presently no way to refer to a method type directly, so
+            // we cannot put type annotations on it.
+            super(methodClass, noAnnotations);
             this.argtypes = argtypes;
             this.restype = restype;
             this.thrown = thrown;
         }
 
         @Override
+        public MethodType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate a method type");
+        }
+
+        @Override
         public TypeTag getTag() {
             return METHOD;
         }
@@ -1138,7 +1233,13 @@
          *  should be.
          */
         public String toString() {
-            return "(" + argtypes + ")" + restype;
+            StringBuilder sb = new StringBuilder();
+            appendAnnotationsString(sb);
+            sb.append('(');
+            sb.append(argtypes);
+            sb.append(')');
+            sb.append(restype);
+            return sb.toString();
         }
 
         public List<Type>        getParameterTypes() { return argtypes; }
@@ -1197,7 +1298,13 @@
     public static class PackageType extends Type implements NoType {
 
         PackageType(TypeSymbol tsym) {
-            super(tsym);
+            // Package types cannot be annotated
+            super(tsym, noAnnotations);
+        }
+
+        @Override
+        public PackageType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate a package type");
         }
 
         @Override
@@ -1245,18 +1352,29 @@
         public Type lower;
 
         public TypeVar(Name name, Symbol owner, Type lower) {
-            super(null);
+            this(name, owner, lower, noAnnotations);
+        }
+
+        public TypeVar(Name name, Symbol owner, Type lower,
+                       List<Attribute.TypeCompound> annos) {
+            super(null, annos);
             tsym = new TypeVariableSymbol(0, name, this, owner);
             this.lower = lower;
         }
 
-        public TypeVar(TypeSymbol tsym, Type bound, Type lower) {
-            super(tsym);
+        public TypeVar(TypeSymbol tsym, Type bound, Type lower,
+                       List<Attribute.TypeCompound> annos) {
+            super(tsym, annos);
             this.bound = bound;
             this.lower = lower;
         }
 
         @Override
+        public TypeVar annotatedType(List<Attribute.TypeCompound> annos) {
+            return new TypeVar(tsym, bound, lower, annos);
+        }
+
+        @Override
         public TypeTag getTag() {
             return TYPEVAR;
         }
@@ -1317,13 +1435,29 @@
                             Symbol owner,
                             Type upper,
                             Type lower,
-                            WildcardType wildcard) {
-            super(name, owner, lower);
+                            WildcardType wildcard,
+                            List<Attribute.TypeCompound> annos) {
+            super(name, owner, lower, annos);
             this.lower = Assert.checkNonNull(lower);
             this.bound = upper;
             this.wildcard = wildcard;
         }
 
+        public CapturedType(TypeSymbol tsym,
+                            Type bound,
+                            Type upper,
+                            Type lower,
+                            WildcardType wildcard,
+                            List<Attribute.TypeCompound> annos) {
+            super(tsym, bound, lower, annos);
+            this.wildcard = wildcard;
+        }
+
+        @Override
+        public CapturedType annotatedType(List<Attribute.TypeCompound> annos) {
+            return new CapturedType(tsym, bound, bound, lower, wildcard, annos);
+        }
+
         @Override
         public <R,S> R accept(Type.Visitor<R,S> v, S s) {
             return v.visitCapturedType(this, s);
@@ -1336,18 +1470,22 @@
 
         @Override
         public String toString() {
-            return "capture#"
-                + (hashCode() & 0xFFFFFFFFL) % Printer.PRIME
-                + " of "
-                + wildcard;
+            StringBuilder sb = new StringBuilder();
+            appendAnnotationsString(sb);
+            sb.append("capture#");
+            sb.append((hashCode() & 0xFFFFFFFFL) % Printer.PRIME);
+            sb.append(" of ");
+            sb.append(wildcard);
+            return sb.toString();
         }
     }
 
     public static abstract class DelegatedType extends Type {
         public Type qtype;
         public TypeTag tag;
-        public DelegatedType(TypeTag tag, Type qtype) {
-            super(qtype.tsym);
+        public DelegatedType(TypeTag tag, Type qtype,
+                             List<Attribute.TypeCompound> annos) {
+            super(qtype.tsym, annos);
             this.tag = tag;
             this.qtype = qtype;
         }
@@ -1373,17 +1511,28 @@
         public List<Type> tvars;
 
         public ForAll(List<Type> tvars, Type qtype) {
-            super(FORALL, (MethodType)qtype);
+            super(FORALL, (MethodType)qtype, noAnnotations);
             this.tvars = tvars;
         }
 
         @Override
+        public ForAll annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate forall type");
+        }
+
+        @Override
         public <R,S> R accept(Type.Visitor<R,S> v, S s) {
             return v.visitForAll(this, s);
         }
 
         public String toString() {
-            return "<" + tvars + ">" + qtype;
+            StringBuilder sb = new StringBuilder();
+            appendAnnotationsString(sb);
+            sb.append('<');
+            sb.append(tvars);
+            sb.append('>');
+            sb.append(qtype);
+            return sb.toString();
         }
 
         public List<Type> getTypeArguments()   { return tvars; }
@@ -1479,7 +1628,8 @@
         }
 
         public UndetVar(TypeVar origin, Types types) {
-            super(UNDETVAR, origin);
+            // This is a synthesized internal type, so we cannot annotate it.
+            super(UNDETVAR, origin, noAnnotations);
             bounds = new EnumMap<>(InferenceBound.class);
             List<Type> declaredBounds = types.getBounds(origin);
             declaredCount = declaredBounds.length();
@@ -1489,7 +1639,15 @@
         }
 
         public String toString() {
-            return (inst == null) ? qtype + "?" : inst.toString();
+            StringBuilder sb = new StringBuilder();
+            appendAnnotationsString(sb);
+            if (inst == null) {
+                sb.append(qtype);
+                sb.append('?');
+            } else {
+                sb.append(inst);
+            }
+            return sb.toString();
         }
 
         public String debugString() {
@@ -1507,6 +1665,11 @@
         }
 
         @Override
+        public UndetVar annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate an UndetVar type");
+        }
+
+        @Override
         public boolean isPartial() {
             return true;
         }
@@ -1659,7 +1822,15 @@
      */
     public static class JCNoType extends Type implements NoType {
         public JCNoType() {
-            super(null);
+            // Need to use List.nil(), because JCNoType constructor
+            // gets called in static initializers in Type, where
+            // noAnnotations is also defined.
+            super(null, List.<Attribute.TypeCompound>nil());
+        }
+
+        @Override
+        public JCNoType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate JCNoType");
         }
 
         @Override
@@ -1686,7 +1857,13 @@
     public static class JCVoidType extends Type implements NoType {
 
         public JCVoidType() {
-            super(null);
+            // Void cannot be annotated
+            super(null, noAnnotations);
+        }
+
+        @Override
+        public JCVoidType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate void type");
         }
 
         @Override
@@ -1715,7 +1892,13 @@
 
     static class BottomType extends Type implements NullType {
         public BottomType() {
-            super(null);
+            // Bottom is a synthesized internal type, so it cannot be annotated
+            super(null, noAnnotations);
+        }
+
+        @Override
+        public BottomType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate bottom type");
         }
 
         @Override
@@ -1759,7 +1942,12 @@
         private Type originalType = null;
 
         public ErrorType(Type originalType, TypeSymbol tsym) {
-            super(noType, List.<Type>nil(), null);
+            this(originalType, tsym, noAnnotations);
+        }
+
+        public ErrorType(Type originalType, TypeSymbol tsym,
+                         List<Attribute.TypeCompound> typeAnnotations) {
+            super(noType, List.<Type>nil(), null, typeAnnotations);
             this.tsym = tsym;
             this.originalType = (originalType == null ? noType : originalType);
         }
@@ -1772,6 +1960,11 @@
         }
 
         @Override
+        public ErrorType annotatedType(List<Attribute.TypeCompound> annos) {
+            return new ErrorType(originalType, tsym, annos);
+        }
+
+        @Override
         public TypeTag getTag() {
             return ERROR;
         }
@@ -1827,182 +2020,17 @@
         }
     }
 
-    public static class AnnotatedType extends Type
-            implements
-                javax.lang.model.type.ArrayType,
-                javax.lang.model.type.DeclaredType,
-                javax.lang.model.type.PrimitiveType,
-                javax.lang.model.type.TypeVariable,
-                javax.lang.model.type.WildcardType {
-        /** The type annotations on this type.
-         */
-        private List<Attribute.TypeCompound> typeAnnotations;
+    public static class UnknownType extends Type {
 
-        /** The underlying type that is annotated.
-         */
-        private Type underlyingType;
-
-        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);
+        public UnknownType() {
+            // Unknown is a synthesized internal type, so it cannot be
+            // annotated.
+            super(null, noAnnotations);
         }
 
         @Override
-        public TypeTag getTag() {
-            return underlyingType.getTag();
-        }
-
-        @Override
-        public boolean isAnnotated() {
-            return true;
-        }
-
-        @Override
-        public List<Attribute.TypeCompound> getAnnotationMirrors() {
-            return typeAnnotations;
-        }
-
-
-        @Override
-        public TypeKind getKind() {
-            return underlyingType.getKind();
-        }
-
-        @Override
-        public Type unannotatedType() {
-            return underlyingType;
-        }
-
-        @Override
-        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
-            return v.visitAnnotatedType(this, s);
-        }
-
-        @Override
-        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
-            return underlyingType.accept(v, p);
-        }
-
-        @Override
-        public Type map(Mapping f) {
-            underlyingType.map(f);
-            return this;
-        }
-
-        @Override
-        public Type constType(Object constValue) { return underlyingType.constType(constValue); }
-        @Override
-        public Type getEnclosingType()           { return underlyingType.getEnclosingType(); }
-
-        @Override
-        public Type getReturnType()              { return underlyingType.getReturnType(); }
-        @Override
-        public List<Type> getTypeArguments()     { return underlyingType.getTypeArguments(); }
-        @Override
-        public List<Type> getParameterTypes()    { return underlyingType.getParameterTypes(); }
-        @Override
-        public Type getReceiverType()            { return underlyingType.getReceiverType(); }
-        @Override
-        public List<Type> getThrownTypes()       { return underlyingType.getThrownTypes(); }
-        @Override
-        public Type getUpperBound()              { return underlyingType.getUpperBound(); }
-        @Override
-        public Type getLowerBound()              { return underlyingType.getLowerBound(); }
-
-        @Override
-        public boolean isErroneous()             { return underlyingType.isErroneous(); }
-        @Override
-        public boolean isCompound()              { return underlyingType.isCompound(); }
-        @Override
-        public boolean isInterface()             { return underlyingType.isInterface(); }
-        @Override
-        public List<Type> allparams()            { return underlyingType.allparams(); }
-        @Override
-        public boolean isPrimitive()             { return underlyingType.isPrimitive(); }
-        @Override
-        public boolean isPrimitiveOrVoid()       { return underlyingType.isPrimitiveOrVoid(); }
-        @Override
-        public boolean isNumeric()               { return underlyingType.isNumeric(); }
-        @Override
-        public boolean isReference()             { return underlyingType.isReference(); }
-        @Override
-        public boolean isNullOrReference()       { return underlyingType.isNullOrReference(); }
-        @Override
-        public boolean isPartial()               { return underlyingType.isPartial(); }
-        @Override
-        public boolean isParameterized()         { return underlyingType.isParameterized(); }
-        @Override
-        public boolean isRaw()                   { return underlyingType.isRaw(); }
-        @Override
-        public boolean isFinal()                 { return underlyingType.isFinal(); }
-        @Override
-        public boolean isSuperBound()            { return underlyingType.isSuperBound(); }
-        @Override
-        public boolean isExtendsBound()          { return underlyingType.isExtendsBound(); }
-        @Override
-        public boolean isUnbound()               { return underlyingType.isUnbound(); }
-
-        @Override
-        public String toString() {
-            // This method is only used for internal debugging output.
-            // See
-            // com.sun.tools.javac.code.Printer.visitAnnotatedType(AnnotatedType, Locale)
-            // for the user-visible logic.
-            if (typeAnnotations != null &&
-                    !typeAnnotations.isEmpty()) {
-                return "(" + typeAnnotations.toString() + " :: " + underlyingType.toString() + ")";
-            } else {
-                return "({} :: " + underlyingType.toString() +")";
-            }
-        }
-
-        @Override
-        public boolean contains(Type t)          { return underlyingType.contains(t); }
-
-        @Override
-        public Type withTypeVar(Type t) {
-            // Don't create a new AnnotatedType, as 'this' will
-            // get its annotations set later.
-            underlyingType = underlyingType.withTypeVar(t);
-            return this;
-        }
-
-        // TODO: attach annotations?
-        @Override
-        public TypeSymbol asElement()            { return underlyingType.asElement(); }
-
-        // TODO: attach annotations?
-        @Override
-        public MethodType asMethodType()         { return underlyingType.asMethodType(); }
-
-        @Override
-        public void complete()                   { underlyingType.complete(); }
-
-        @Override
-        public TypeMirror getComponentType()     { return ((ArrayType)underlyingType).getComponentType(); }
-
-        // The result is an ArrayType, but only in the model sense, not the Type sense.
-        public Type makeVarargs() {
-            return ((ArrayType) underlyingType).makeVarargs().annotatedType(typeAnnotations);
-        }
-
-        @Override
-        public TypeMirror getExtendsBound()      { return ((WildcardType)underlyingType).getExtendsBound(); }
-        @Override
-        public TypeMirror getSuperBound()        { return ((WildcardType)underlyingType).getSuperBound(); }
-    }
-
-    public static class UnknownType extends Type {
-
-        public UnknownType() {
-            super(null);
+        public UnknownType annotatedType(List<Attribute.TypeCompound> annos) {
+            throw new AssertionError("Cannot annotate unknown type");
         }
 
         @Override
@@ -2046,7 +2074,6 @@
         R visitForAll(ForAll t, S s);
         R visitUndetVar(UndetVar t, S s);
         R visitErrorType(ErrorType t, S s);
-        R visitAnnotatedType(AnnotatedType t, S s);
         R visitType(Type t, S s);
     }
 }
--- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Fri May 09 09:28:47 2014 -0400
@@ -326,15 +326,21 @@
 
     public int getCatchType() {
         Assert.check(hasCatchType(),
-                     "exception_index does not contain a valid catch type");
-        return (-this.exception_index) - 1 ;
+                     "exception_index does not contain valid catch info");
+        return ((-this.exception_index) - 1) & 0xff ;
     }
 
-    public void setCatchType(final int catchType) {
+    public int getStartPos() {
+        Assert.check(hasCatchType(),
+                     "exception_index does not contain valid catch info");
+        return ((-this.exception_index) - 1) >> 8 ;
+    }
+
+    public void setCatchInfo(final int catchType, final int startPos) {
         Assert.check(this.exception_index < 0,
                      "exception_index already contains a bytecode index");
         Assert.check(catchType >= 0, "Expected a valid catch type");
-        this.exception_index = -(catchType + 1);
+        this.exception_index = -((catchType | startPos << 8) + 1);
     }
 
     /**
--- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Fri May 09 09:28:47 2014 -0400
@@ -32,7 +32,6 @@
 import javax.tools.JavaFileObject;
 
 import com.sun.tools.javac.code.Attribute.TypeCompound;
-import com.sun.tools.javac.code.Type.AnnotatedType;
 import com.sun.tools.javac.code.Type.ArrayType;
 import com.sun.tools.javac.code.Type.CapturedType;
 import com.sun.tools.javac.code.Type.ClassType;
@@ -331,7 +330,6 @@
                 // Note that we don't use the result, the call to
                 // typeWithAnnotations side-effects the type annotation positions.
                 // This is important for constructors of nested classes.
-
                 sym.appendUniqueTypeAttributes(typeAnnotations);
                 return;
             }
@@ -391,14 +389,15 @@
         private Type typeWithAnnotations(final JCTree typetree, final Type type,
                 final List<Attribute.TypeCompound> annotations,
                 final List<Attribute.TypeCompound> onlyTypeAnnotations) {
-            // System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s, onlyTypeAnnotations: %s)%n",
+            //System.err.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.ArrayType arType = (Type.ArrayType) type;
+                Type.ArrayType tomodify = new Type.ArrayType(null, arType.tsym,
+                                                             Type.noAnnotations);
                 Type toreturn;
                 if (type.isAnnotated()) {
                     toreturn = tomodify.annotatedType(type.getAnnotationMirrors());
@@ -413,13 +412,15 @@
                 while (arType.elemtype.hasTag(TypeTag.ARRAY)) {
                     if (arType.elemtype.isAnnotated()) {
                         Type aelemtype = arType.elemtype;
-                        arType = (Type.ArrayType) aelemtype.unannotatedType();
+                        arType = (Type.ArrayType) aelemtype;
                         ArrayType prevToMod = tomodify;
-                        tomodify = new Type.ArrayType(null, arType.tsym);
+                        tomodify = new Type.ArrayType(null, arType.tsym,
+                                                      Type.noAnnotations);
                         prevToMod.elemtype = tomodify.annotatedType(arType.elemtype.getAnnotationMirrors());
                     } else {
                         arType = (Type.ArrayType) arType.elemtype;
-                        tomodify.elemtype = new Type.ArrayType(null, arType.tsym);
+                        tomodify.elemtype = new Type.ArrayType(null, arType.tsym,
+                                                               Type.noAnnotations);
                         tomodify = (Type.ArrayType) tomodify.elemtype;
                     }
                     arTree = arrayTypeTree(arTree.elemtype);
@@ -569,6 +570,7 @@
         private Type typeWithAnnotations(final Type type,
                 final Type stopAt,
                 final List<Attribute.TypeCompound> annotations) {
+            //System.err.println("typeWithAnnotations " + type + " " + annotations + " stopAt " + stopAt);
             Visitor<Type, List<TypeCompound>> visitor =
                     new Type.Visitor<Type, List<Attribute.TypeCompound>>() {
                 @Override
@@ -579,7 +581,8 @@
                         return t.annotatedType(s);
                     } else {
                         ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),
-                                t.typarams_field, t.tsym);
+                                                      t.typarams_field, t.tsym,
+                                                      t.getAnnotationMirrors());
                         ret.all_interfaces_field = t.all_interfaces_field;
                         ret.allparams_field = t.allparams_field;
                         ret.interfaces_field = t.interfaces_field;
@@ -590,18 +593,14 @@
                 }
 
                 @Override
-                public Type visitAnnotatedType(AnnotatedType t, List<TypeCompound> s) {
-                    return t.unannotatedType().accept(this, s).annotatedType(t.getAnnotationMirrors());
-                }
-
-                @Override
                 public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {
                     return t.annotatedType(s);
                 }
 
                 @Override
                 public Type visitArrayType(ArrayType t, List<TypeCompound> s) {
-                    ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym);
+                    ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym,
+                                                  t.getAnnotationMirrors());
                     return ret;
                 }
 
--- a/src/share/classes/com/sun/tools/javac/code/Types.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Fri May 09 09:28:47 2014 -0400
@@ -131,7 +131,7 @@
      * @return the upper bound of the given type
      */
     public Type upperBound(Type t) {
-        return upperBound.visit(t).unannotatedType();
+        return upperBound.visit(t);
     }
     // where
         private final MapVisitor<Void> upperBound = new MapVisitor<Void>() {
@@ -205,7 +205,7 @@
                     WildcardType unb = new WildcardType(syms.objectType,
                                                         BoundKind.UNBOUND,
                                                         syms.boundClass,
-                                                        (TypeVar)parms.head.unannotatedType());
+                                                        (TypeVar)parms.head);
                     if (!containsType(args.head, unb))
                         return false;
                     parms = parms.tail;
@@ -269,7 +269,9 @@
                         List<Type> opens = openVars.toList();
                         ListBuffer<Type> qs = new ListBuffer<>();
                         for (List<Type> iter = opens; iter.nonEmpty(); iter = iter.tail) {
-                            qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head.unannotatedType()));
+                            qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND,
+                                                       syms.boundClass, (TypeVar) iter.head,
+                                                       Type.noAnnotations));
                         }
                         res = subst(res, opens, qs.toList());
                     }
@@ -599,12 +601,12 @@
             //simply replace the wildcards with its bound
             for (Type t : formalInterface.getTypeArguments()) {
                 if (actualTypeargs.head.hasTag(WILDCARD)) {
-                    WildcardType wt = (WildcardType)actualTypeargs.head.unannotatedType();
+                    WildcardType wt = (WildcardType)actualTypeargs.head;
                     Type bound;
                     switch (wt.kind) {
                         case EXTENDS:
                         case UNBOUND:
-                            CapturedType capVar = (CapturedType)capturedTypeargs.head.unannotatedType();
+                            CapturedType capVar = (CapturedType)capturedTypeargs.head;
                             //use declared bound if it doesn't depend on formal type-args
                             bound = capVar.bound.containsAny(capturedSite.getTypeArguments()) ?
                                     wt.type : capVar.bound;
@@ -642,7 +644,8 @@
         csym.members_field = new Scope(csym);
         MethodSymbol instDescSym = new MethodSymbol(descSym.flags(), descSym.name, descType, csym);
         csym.members_field.enter(instDescSym);
-        Type.ClassType ctype = new Type.ClassType(Type.noType, List.<Type>nil(), csym);
+        Type.ClassType ctype = new Type.ClassType(Type.noType, List.<Type>nil(), csym,
+                                                  Type.noAnnotations);
         ctype.supertype_field = syms.objectType;
         ctype.interfaces_field = targets;
         csym.type = ctype;
@@ -747,8 +750,6 @@
     //where
         private boolean isSubtypeUncheckedInternal(Type t, Type s, Warner warn) {
             if (t.hasTag(ARRAY) && s.hasTag(ARRAY)) {
-                t = t.unannotatedType();
-                s = s.unannotatedType();
                 if (((ArrayType)t).elemtype.isPrimitive()) {
                     return isSameType(elemtype(t), elemtype(s));
                 } else {
@@ -776,8 +777,6 @@
             if (!t.hasTag(ARRAY) || isReifiable(t)) {
                 return;
             }
-            t = t.unannotatedType();
-            s = s.unannotatedType();
             ArrayType from = (ArrayType)t;
             boolean shouldWarn = false;
             switch (s.getTag()) {
@@ -810,12 +809,6 @@
         if (t == s)
             return true;
 
-        t = t.unannotatedType();
-        s = s.unannotatedType();
-
-        if (t == s)
-            return true;
-
         if (s.isPartial())
             return isSuperType(s, t);
 
@@ -899,12 +892,14 @@
                     if (s.isSuperBound() && !s.isExtendsBound()) {
                         s = new WildcardType(syms.objectType,
                                              BoundKind.UNBOUND,
-                                             syms.boundClass);
+                                             syms.boundClass,
+                                             s.getAnnotationMirrors());
                         changed = true;
                     } else if (s != orig) {
                         s = new WildcardType(upperBound(s),
                                              BoundKind.EXTENDS,
-                                             syms.boundClass);
+                                             syms.boundClass,
+                                             s.getAnnotationMirrors());
                         changed = true;
                     }
                     rewrite.append(s);
@@ -1107,7 +1102,7 @@
                     if (s.hasTag(TYPEVAR)) {
                         //type-substitution does not preserve type-var types
                         //check that type var symbols and bounds are indeed the same
-                        return sameTypeVars((TypeVar)t.unannotatedType(), (TypeVar)s.unannotatedType());
+                        return sameTypeVars((TypeVar)t, (TypeVar)s);
                     }
                     else {
                         //special case for s == ? super X, where upper(s) = u
@@ -1149,9 +1144,9 @@
 
                     HashSet<UniqueType> set = new HashSet<>();
                     for (Type x : interfaces(t))
-                        set.add(new UniqueType(x.unannotatedType(), Types.this));
+                        set.add(new UniqueType(x, Types.this));
                     for (Type x : interfaces(s)) {
-                        if (!set.remove(new UniqueType(x.unannotatedType(), Types.this)))
+                        if (!set.remove(new UniqueType(x, Types.this)))
                             return false;
                     }
                     return (set.isEmpty());
@@ -1256,30 +1251,47 @@
                 if (!s.hasTag(WILDCARD)) {
                     return false;
                 } else {
-                    WildcardType t2 = (WildcardType)s.unannotatedType();
+                    WildcardType t2 = (WildcardType)s;
                     return t.kind == t2.kind &&
                             isSameType(t.type, t2.type, true);
                 }
             }
         };
 
-        /**
-         * A version of LooseSameTypeVisitor that takes AnnotatedTypes
-         * into account.
-         */
-        TypeRelation isSameAnnotatedType = new LooseSameTypeVisitor() {
+    // </editor-fold>
+
+    TypeRelation isSameAnnotatedType = new LooseSameTypeVisitor() {
+            private Boolean compareAnnotations(Type t1, Type t2) {
+                List<Attribute.TypeCompound> annos1 = t1.getAnnotationMirrors();
+                List<Attribute.TypeCompound> annos2 = t2.getAnnotationMirrors();
+                return annos1.containsAll(annos2) && annos2.containsAll(annos1);
+            }
+
             @Override
-            public Boolean visitAnnotatedType(AnnotatedType t, Type s) {
-                if (!s.isAnnotated())
-                    return false;
-                if (!t.getAnnotationMirrors().containsAll(s.getAnnotationMirrors()))
-                    return false;
-                if (!s.getAnnotationMirrors().containsAll(t.getAnnotationMirrors()))
-                    return false;
-                return visit(t.unannotatedType(), s);
+            public Boolean visitType(Type t, Type s) {
+                return compareAnnotations(t, s) && super.visitType(t, s);
+            }
+
+            @Override
+            public Boolean visitWildcardType(WildcardType t, Type s) {
+                return compareAnnotations(t, s) && super.visitWildcardType(t, s);
+            }
+
+            @Override
+            public Boolean visitClassType(ClassType t, Type s) {
+                return compareAnnotations(t, s) && super.visitClassType(t, s);
+            }
+
+            @Override
+            public Boolean visitArrayType(ArrayType t, Type s) {
+                return compareAnnotations(t, s) && super.visitArrayType(t, s);
+            }
+
+            @Override
+            public Boolean visitForAll(ForAll t, Type s) {
+                return compareAnnotations(t, s) && super.visitForAll(t, s);
             }
         };
-    // </editor-fold>
 
     // <editor-fold defaultstate="collapsed" desc="Contains Type">
     public boolean containedBy(Type t, Type s) {
@@ -1287,7 +1299,7 @@
         case UNDETVAR:
             if (s.hasTag(WILDCARD)) {
                 UndetVar undetvar = (UndetVar)t;
-                WildcardType wt = (WildcardType)s.unannotatedType();
+                WildcardType wt = (WildcardType)s;
                 switch(wt.kind) {
                     case UNBOUND: //similar to ? extends Object
                     case EXTENDS: {
@@ -1354,7 +1366,7 @@
 
             private Type U(Type t) {
                 while (t.hasTag(WILDCARD)) {
-                    WildcardType w = (WildcardType)t.unannotatedType();
+                    WildcardType w = (WildcardType)t;
                     if (w.isSuperBound())
                         return w.bound == null ? syms.objectType : w.bound.bound;
                     else
@@ -1365,7 +1377,7 @@
 
             private Type L(Type t) {
                 while (t.hasTag(WILDCARD)) {
-                    WildcardType w = (WildcardType)t.unannotatedType();
+                    WildcardType w = (WildcardType)t;
                     if (w.isExtendsBound())
                         return syms.botType;
                     else
@@ -1424,15 +1436,15 @@
         };
 
     public boolean isCaptureOf(Type s, WildcardType t) {
-        if (!s.hasTag(TYPEVAR) || !((TypeVar)s.unannotatedType()).isCaptured())
+        if (!s.hasTag(TYPEVAR) || !((TypeVar)s).isCaptured())
             return false;
-        return isSameWildcard(t, ((CapturedType)s.unannotatedType()).wildcard);
+        return isSameWildcard(t, ((CapturedType)s).wildcard);
     }
 
     public boolean isSameWildcard(WildcardType t, Type s) {
         if (!s.hasTag(WILDCARD))
             return false;
-        WildcardType w = (WildcardType)s.unannotatedType();
+        WildcardType w = (WildcardType)s;
         return w.kind == t.kind && w.type == t.type;
     }
 
@@ -1541,8 +1553,8 @@
 
                 if (t.isCompound() || s.isCompound()) {
                     return !t.isCompound() ?
-                            visitIntersectionType((IntersectionClassType)s.unannotatedType(), t, true) :
-                            visitIntersectionType((IntersectionClassType)t.unannotatedType(), s, false);
+                            visitIntersectionType((IntersectionClassType)s, t, true) :
+                            visitIntersectionType((IntersectionClassType)t, s, false);
                 }
 
                 if (s.hasTag(CLASS) || s.hasTag(ARRAY)) {
@@ -1873,7 +1885,6 @@
         case WILDCARD:
             return elemtype(upperBound(t));
         case ARRAY:
-            t = t.unannotatedType();
             return ((ArrayType)t).elemtype;
         case FORALL:
             return elemtype(((ForAll)t).qtype);
@@ -1920,7 +1931,7 @@
         if (t.hasTag(VOID) || t.hasTag(PACKAGE)) {
             Assert.error("Type t must not be a VOID or PACKAGE type, " + t.toString());
         }
-        return new ArrayType(t, syms.arrayClass);
+        return new ArrayType(t, syms.arrayClass, Type.noAnnotations);
     }
     // </editor-fold>
 
@@ -2175,56 +2186,65 @@
     }
 
     private Type erasure(Type t, boolean recurse) {
-        if (t.isPrimitive())
+        if (t.isPrimitive()) {
             return t; /* fast special case */
-        else
-            return erasure.visit(t, recurse);
+        } else {
+            Type out = erasure.visit(t, recurse);
+            return out;
+        }
         }
     // where
         private SimpleVisitor<Type, Boolean> erasure = new SimpleVisitor<Type, Boolean>() {
             public Type visitType(Type t, Boolean recurse) {
                 if (t.isPrimitive())
                     return t; /*fast special case*/
-                else
-                    return t.map(recurse ? erasureRecFun : erasureFun);
+                else {
+                    final List<Attribute.TypeCompound> annos = t.getAnnotationMirrors();
+                    Type erased = t.map(recurse ? erasureRecFun : erasureFun);
+                    if (!annos.isEmpty()) {
+                        erased = erased.annotatedType(annos);
+                    }
+                    return erased;
+                }
             }
 
             @Override
             public Type visitWildcardType(WildcardType t, Boolean recurse) {
-                return erasure(upperBound(t), recurse);
+                final List<Attribute.TypeCompound> annos = t.getAnnotationMirrors();
+                Type erased = erasure(upperBound(t), recurse);
+                if (!annos.isEmpty()) {
+                    erased = erased.annotatedType(annos);
+                }
+                return erased;
             }
 
             @Override
             public Type visitClassType(ClassType t, Boolean recurse) {
                 Type erased = t.tsym.erasure(Types.this);
+                List<Attribute.TypeCompound> annos = t.getAnnotationMirrors();
                 if (recurse) {
                     erased = new ErasedClassType(erased.getEnclosingType(),erased.tsym);
                 }
+                if (!annos.isEmpty()) {
+                    erased = erased.annotatedType(annos);
+                }
                 return erased;
             }
 
             @Override
             public Type visitTypeVar(TypeVar t, Boolean recurse) {
-                return erasure(t.bound, recurse);
+                final List<Attribute.TypeCompound> annos = t.getAnnotationMirrors();
+                Type erased = erasure(t.bound, recurse);
+                if (!annos.isEmpty()) {
+                    erased = erased.annotatedType(annos);
+                }
+                return erased;
             }
 
             @Override
             public Type visitErrorType(ErrorType t, Boolean recurse) {
                 return t;
             }
-
-            @Override
-            public Type visitAnnotatedType(AnnotatedType t, Boolean 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).unannotatedType();
-                }
-                return erased.annotatedType(t.getAnnotationMirrors());
-            }
         };
 
     private Mapping erasureFun = new Mapping ("erasure") {
@@ -2550,7 +2570,8 @@
             public Type visitClassType(ClassType t, Void ignored) {
                 Type outer1 = classBound(t.getEnclosingType());
                 if (outer1 != t.getEnclosingType())
-                    return new ClassType(outer1, t.getTypeArguments(), t.tsym);
+                    return new ClassType(outer1, t.getTypeArguments(), t.tsym,
+                                         t.getAnnotationMirrors());
                 else
                     return t;
             }
@@ -2965,7 +2986,8 @@
                 if (typarams1 == typarams && outer1 == outer)
                     return t;
                 else
-                    return new ClassType(outer1, typarams1, t.tsym);
+                    return new ClassType(outer1, typarams1, t.tsym,
+                                         t.getAnnotationMirrors());
             } else {
                 Type st = subst(supertype(t));
                 List<Type> is = upperBounds(subst(interfaces(t)));
@@ -2986,7 +3008,8 @@
             } else {
                 if (t.isExtendsBound() && bound.isExtendsBound())
                     bound = upperBound(bound);
-                return new WildcardType(bound, t.kind, syms.boundClass, t.bound);
+                return new WildcardType(bound, t.kind, syms.boundClass,
+                                        t.bound, t.getAnnotationMirrors());
             }
         }
 
@@ -2996,7 +3019,7 @@
             if (elemtype == t.elemtype)
                 return t;
             else
-                return new ArrayType(elemtype, t.tsym);
+                return new ArrayType(elemtype, t.tsym, t.getAnnotationMirrors());
         }
 
         @Override
@@ -3006,7 +3029,7 @@
                 //if 'to' types contain variables that are free in 't'
                 List<Type> freevars = newInstances(t.tvars);
                 t = new ForAll(freevars,
-                        Types.this.subst(t.qtype, t.tvars, freevars));
+                               Types.this.subst(t.qtype, t.tvars, freevars));
             }
             List<Type> tvars1 = substBounds(t.tvars, from, to);
             Type qtype1 = subst(t.qtype);
@@ -3015,7 +3038,8 @@
             } else if (tvars1 == t.tvars) {
                 return new ForAll(tvars1, qtype1);
             } else {
-                return new ForAll(tvars1, Types.this.subst(qtype1, t.tvars, tvars1));
+                return new ForAll(tvars1,
+                                  Types.this.subst(qtype1, t.tvars, tvars1));
             }
         }
 
@@ -3045,7 +3069,8 @@
         ListBuffer<Type> newTvars = new ListBuffer<>();
         // create new type variables without bounds
         for (Type t : tvars) {
-            newTvars.append(new TypeVar(t.tsym, null, syms.botType));
+            newTvars.append(new TypeVar(t.tsym, null, syms.botType,
+                                        t.getAnnotationMirrors()));
         }
         // the new bounds should use the new type variables in place
         // of the old
@@ -3071,7 +3096,8 @@
             return t;
         else {
             // create new type variable without bounds
-            TypeVar tv = new TypeVar(t.tsym, null, syms.botType);
+            TypeVar tv = new TypeVar(t.tsym, null, syms.botType,
+                                     t.getAnnotationMirrors());
             // the new bound should use the new type variable in place
             // of the old
             tv.bound = subst(bound1, List.<Type>of(t), List.<Type>of(tv));
@@ -3112,7 +3138,7 @@
         return tvars1;
     }
     private static final Mapping newInstanceFun = new Mapping("newInstanceFun") {
-            public Type apply(Type t) { return new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound()); }
+            public Type apply(Type t) { return new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound(), t.getAnnotationMirrors()); }
         };
     // </editor-fold>
 
@@ -3185,7 +3211,6 @@
      * graph. Undefined for all but reference types.
      */
     public int rank(Type t) {
-        t = t.unannotatedType();
         switch(t.getTag()) {
         case CLASS: {
             ClassType cls = (ClassType)t;
@@ -3267,7 +3292,7 @@
             for (Type t : tvars) {
                 if (!first) s.append(", ");
                 first = false;
-                appendTyparamString(((TypeVar)t.unannotatedType()), s);
+                appendTyparamString(((TypeVar)t), s);
             }
             s.append('>');
             return s.toString();
@@ -3439,12 +3464,14 @@
                         m = new WildcardType(lub(upperBound(act1.head),
                                                  upperBound(act2.head)),
                                              BoundKind.EXTENDS,
-                                             syms.boundClass);
+                                             syms.boundClass,
+                                             Type.noAnnotations);
                         mergeCache.remove(pair);
                     } else {
                         m = new WildcardType(syms.objectType,
                                              BoundKind.UNBOUND,
-                                             syms.boundClass);
+                                             syms.boundClass,
+                                             Type.noAnnotations);
                     }
                     merged.append(m.withTypeVar(typarams.head));
                 }
@@ -3453,7 +3480,10 @@
                 typarams = typarams.tail;
             }
             Assert.check(act1.isEmpty() && act2.isEmpty() && typarams.isEmpty());
-            return new ClassType(class1.getEnclosingType(), merged.toList(), class1.tsym);
+            // There is no spec detailing how type annotations are to
+            // be inherited.  So set it to noAnnotations for now
+            return new ClassType(class1.getEnclosingType(), merged.toList(),
+                                 class1.tsym, Type.noAnnotations);
         }
 
     /**
@@ -3571,7 +3601,8 @@
                 }
             }
             // lub(A[], B[]) is lub(A, B)[]
-            return new ArrayType(lub(elements), syms.arrayClass);
+            return new ArrayType(lub(elements), syms.arrayClass,
+                                 Type.noAnnotations);
 
         case CLASS_BOUND:
             // calculate lub(A, B)
@@ -3932,7 +3963,6 @@
                 t = subst(type1, t.tsym.type.getTypeArguments(), t.getTypeArguments());
             }
         }
-        t = t.unannotatedType();
         ClassType cls = (ClassType)t;
         if (cls.isRaw() || !cls.isParameterized())
             return cls;
@@ -3951,9 +3981,9 @@
                !currentS.isEmpty()) {
             if (currentS.head != currentT.head) {
                 captured = true;
-                WildcardType Ti = (WildcardType)currentT.head.unannotatedType();
+                WildcardType Ti = (WildcardType)currentT.head;
                 Type Ui = currentA.head.getUpperBound();
-                CapturedType Si = (CapturedType)currentS.head.unannotatedType();
+                CapturedType Si = (CapturedType)currentS.head;
                 if (Ui == null)
                     Ui = syms.objectType;
                 switch (Ti.kind) {
@@ -3986,7 +4016,8 @@
             return erasure(t); // some "rare" type involved
 
         if (captured)
-            return new ClassType(cls.getEnclosingType(), S, cls.tsym);
+            return new ClassType(cls.getEnclosingType(), S, cls.tsym,
+                                 cls.getAnnotationMirrors());
         else
             return t;
     }
@@ -3995,7 +4026,6 @@
             ListBuffer<Type> result = new ListBuffer<>();
             for (Type t : types) {
                 if (t.hasTag(WILDCARD)) {
-                    t = t.unannotatedType();
                     Type bound = ((WildcardType)t).getExtendsBound();
                     if (bound == null)
                         bound = syms.objectType;
@@ -4003,7 +4033,8 @@
                                                    syms.noSymbol,
                                                    bound,
                                                    syms.botType,
-                                                   (WildcardType)t));
+                                                   (WildcardType)t,
+                                                   Type.noAnnotations));
                 } else {
                     result.append(t);
                 }
@@ -4089,7 +4120,7 @@
 
     private boolean giveWarning(Type from, Type to) {
         List<Type> bounds = to.isCompound() ?
-                ((IntersectionClassType)to.unannotatedType()).getComponents() : List.of(to);
+                ((IntersectionClassType)to).getComponents() : List.of(to);
         for (Type b : bounds) {
             Type subFrom = asSub(from, b.tsym);
             if (b.isParameterized() &&
@@ -4354,7 +4385,7 @@
 
         Type B(Type t) {
             while (t.hasTag(WILDCARD)) {
-                WildcardType w = (WildcardType)t.unannotatedType();
+                WildcardType w = (WildcardType)t;
                 t = high ?
                     w.getExtendsBound() :
                     w.getSuperBound();
@@ -4380,12 +4411,14 @@
             return new WildcardType(syms.objectType,
                                     BoundKind.UNBOUND,
                                     syms.boundClass,
-                                    formal);
+                                    formal,
+                                    Type.noAnnotations);
         } else {
             return new WildcardType(bound,
                                     BoundKind.EXTENDS,
                                     syms.boundClass,
-                                    formal);
+                                    formal,
+                                    Type.noAnnotations);
         }
     }
 
@@ -4402,12 +4435,14 @@
             return new WildcardType(syms.objectType,
                                     BoundKind.UNBOUND,
                                     syms.boundClass,
-                                    formal);
+                                    formal,
+                                    Type.noAnnotations);
         } else {
             return new WildcardType(bound,
                                     BoundKind.SUPER,
                                     syms.boundClass,
-                                    formal);
+                                    formal,
+                                    Type.noAnnotations);
         }
     }
 
@@ -4429,7 +4464,7 @@
 
         public boolean equals(Object obj) {
             return (obj instanceof UniqueType) &&
-                types.isSameAnnotatedType(type, ((UniqueType)obj).type);
+                types.isSameType(type, ((UniqueType)obj).type);
         }
 
         public String toString() {
@@ -4464,8 +4499,6 @@
         public R visitForAll(ForAll t, S s)             { return visitType(t, s); }
         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.unannotatedType(), s); }
     }
 
     /**
@@ -4596,7 +4629,6 @@
          * Assemble signature of given type in string buffer.
          */
         public void assembleSig(Type type) {
-            type = type.unannotatedType();
             switch (type.getTag()) {
                 case BYTE:
                     append('B');
@@ -4693,7 +4725,6 @@
         }
 
         public void assembleClassSig(Type type) {
-            type = type.unannotatedType();
             ClassType ct = (ClassType) type;
             ClassSymbol c = (ClassSymbol) ct.tsym;
             classReference(c);
--- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Fri May 09 09:28:47 2014 -0400
@@ -1865,8 +1865,10 @@
                 return new ClassType(restype.getEnclosingType(),
                               List.<Type>of(new WildcardType(types.erasure(qualifierType),
                                                                BoundKind.EXTENDS,
-                                                               syms.boundClass)),
-                              restype.tsym);
+                                                             syms.boundClass,
+                                                             Type.noAnnotations)),
+                                     restype.tsym,
+                                     restype.getAnnotationMirrors());
             } else {
                 return restype;
             }
@@ -2036,7 +2038,8 @@
             } else if (TreeInfo.isDiamond(tree)) {
                 ClassType site = new ClassType(clazztype.getEnclosingType(),
                             clazztype.tsym.type.getTypeArguments(),
-                            clazztype.tsym);
+                                               clazztype.tsym,
+                                               clazztype.getAnnotationMirrors());
 
                 Env<AttrContext> diamondEnv = localEnv.dup(tree);
                 diamondEnv.info.selectSuper = cdef != null;
@@ -2255,7 +2258,8 @@
             owntype = elemtype;
             for (List<JCExpression> l = tree.dims; l.nonEmpty(); l = l.tail) {
                 attribExpr(l.head, localEnv, syms.intType);
-                owntype = new ArrayType(owntype, syms.arrayClass);
+                owntype = new ArrayType(owntype, syms.arrayClass,
+                                        Type.noAnnotations);
             }
         } else {
             // we are seeing an untyped aggregate { ... }
@@ -2272,7 +2276,8 @@
         }
         if (tree.elems != null) {
             attribExprs(tree.elems, localEnv, elemtype);
-            owntype = new ArrayType(elemtype, syms.arrayClass);
+            owntype = new ArrayType(elemtype, syms.arrayClass,
+                                    Type.noAnnotations);
         }
         if (!types.isReifiable(elemtype))
             log.error(tree.pos(), "generic.array.creation");
@@ -3244,7 +3249,7 @@
         if (skind == TYP) {
             Type elt = site;
             while (elt.hasTag(ARRAY))
-                elt = ((ArrayType)elt.unannotatedType()).elemtype;
+                elt = ((ArrayType)elt).elemtype;
             if (elt.hasTag(TYPEVAR)) {
                 log.error(tree.pos(), "type.var.cant.be.deref");
                 result = types.createErrorType(tree.type);
@@ -3557,7 +3562,8 @@
                             normOuter = types.erasure(ownOuter);
                         if (normOuter != ownOuter)
                             owntype = new ClassType(
-                                normOuter, List.<Type>nil(), owntype.tsym);
+                                normOuter, List.<Type>nil(), owntype.tsym,
+                                owntype.getAnnotationMirrors());
                     }
                 }
                 break;
@@ -3861,7 +3867,7 @@
 
     public void visitTypeArray(JCArrayTypeTree tree) {
         Type etype = attribType(tree.elemtype, env);
-        Type type = new ArrayType(etype, syms.arrayClass);
+        Type type = new ArrayType(etype, syms.arrayClass, Type.noAnnotations);
         result = check(tree, type, TYP, resultInfo);
     }
 
@@ -3909,7 +3915,8 @@
                         clazzOuter = site;
                     }
                 }
-                owntype = new ClassType(clazzOuter, actuals, clazztype.tsym);
+                owntype = new ClassType(clazzOuter, actuals, clazztype.tsym,
+                                        clazztype.getAnnotationMirrors());
             } else {
                 if (formals.length() != 0) {
                     log.error(tree.pos(), "wrong.number.type.args",
@@ -4060,7 +4067,8 @@
             : attribType(tree.inner, env);
         result = check(tree, new WildcardType(chk.checkRefType(tree.pos(), type),
                                               tree.kind.kind,
-                                              syms.boundClass),
+                                              syms.boundClass,
+                                              Type.noAnnotations),
                        TYP, resultInfo);
     }
 
@@ -4088,7 +4096,7 @@
             public void run() {
                 List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
                 Assert.check(annotations.size() == compounds.size());
-                    tree.type = tree.type.unannotatedType().annotatedType(compounds);
+                tree.type = tree.type.annotatedType(compounds);
                 }
         });
     }
@@ -4470,6 +4478,7 @@
             }
         }
         public void visitVarDef(final JCVariableDecl tree) {
+            //System.err.println("validateTypeAnnotations.visitVarDef " + tree);
             if (tree.sym != null && tree.sym.type != null)
                 validateAnnotatedType(tree.vartype, tree.sym.type);
             scan(tree.mods);
@@ -4512,6 +4521,7 @@
             super.visitNewArray(tree);
         }
         public void visitClassDef(JCClassDecl tree) {
+            //System.err.println("validateTypeAnnotations.visitClassDef " + tree);
             if (sigOnly) {
                 scan(tree.mods);
                 scan(tree.typarams);
@@ -4540,7 +4550,7 @@
          * can occur.
          */
         private void validateAnnotatedType(final JCTree errtree, final Type type) {
-            // System.out.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
+            //System.err.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
 
             if (type.isPrimitiveOrVoid()) {
                 return;
@@ -4578,8 +4588,7 @@
                     }
                 } else if (enclTr.hasTag(ANNOTATED_TYPE)) {
                     JCAnnotatedType at = (JCTree.JCAnnotatedType) enclTr;
-                    if (enclTy == null ||
-                            enclTy.hasTag(NONE)) {
+                    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 {
@@ -4598,16 +4607,16 @@
                 } 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());
+                        validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy).getExtendsBound());
                     } else if (wc.getKind() == JCTree.Kind.SUPER_WILDCARD) {
-                        validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy.unannotatedType()).getSuperBound());
+                        validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy).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());
+                    validateAnnotatedType(art.getType(), ((ArrayType)enclTy).getComponentType());
                     repeat = false;
                 } else if (enclTr.hasTag(TYPEUNION)) {
                     JCTypeUnion ut = (JCTypeUnion) enclTr;
--- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Fri May 09 09:28:47 2014 -0400
@@ -2234,11 +2234,11 @@
         if  (t.hasTag(TYPEVAR) && (t.tsym.flags() & UNATTRIBUTED) != 0)
             return;
         if (seen.contains(t)) {
-            tv = (TypeVar)t.unannotatedType();
+            tv = (TypeVar)t;
             tv.bound = types.createErrorType(t);
             log.error(pos, "cyclic.inheritance", t);
         } else if (t.hasTag(TYPEVAR)) {
-            tv = (TypeVar)t.unannotatedType();
+            tv = (TypeVar)t;
             seen = seen.prepend(tv);
             for (Type b : types.getBounds(tv))
                 checkNonCyclic1(pos, b, seen);
--- a/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Fri May 09 09:28:47 2014 -0400
@@ -134,13 +134,18 @@
         SpeculativeCache speculativeCache;
 
         DeferredType(JCExpression tree, Env<AttrContext> env) {
-            super(null);
+            super(null, noAnnotations);
             this.tree = tree;
             this.env = attr.copyEnv(env);
             this.speculativeCache = new SpeculativeCache();
         }
 
         @Override
+        public DeferredType annotatedType(List<Attribute.TypeCompound> typeAnnotations) {
+            throw new AssertionError("Cannot annotate a deferred type");
+        }
+
+        @Override
         public TypeTag getTag() {
             return DEFERRED;
         }
--- a/src/share/classes/com/sun/tools/javac/comp/Infer.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/Infer.java	Fri May 09 09:28:47 2014 -0400
@@ -373,7 +373,7 @@
             List<Type> upperBounds = uv.getBounds(InferenceBound.UPPER);
             if (Type.containsAny(upperBounds, vars)) {
                 TypeSymbol fresh_tvar = new TypeVariableSymbol(Flags.SYNTHETIC, uv.qtype.tsym.name, null, uv.qtype.tsym.owner);
-                fresh_tvar.type = new TypeVar(fresh_tvar, types.makeCompoundType(uv.getBounds(InferenceBound.UPPER)), null);
+                fresh_tvar.type = new TypeVar(fresh_tvar, types.makeCompoundType(uv.getBounds(InferenceBound.UPPER)), null, Type.noAnnotations);
                 todo.append(uv);
                 uv.inst = fresh_tvar.type;
             } else if (upperBounds.nonEmpty()) {
@@ -1505,7 +1505,9 @@
                         LOWER.solve(uv, inferenceContext) :
                         infer.syms.botType;
                 CapturedType prevCaptured = (CapturedType)uv.qtype;
-                return new CapturedType(prevCaptured.tsym.name, prevCaptured.tsym.owner, upper, lower, prevCaptured.wildcard);
+                return new CapturedType(prevCaptured.tsym.name, prevCaptured.tsym.owner,
+                                        upper, lower, prevCaptured.wildcard,
+                                        Type.noAnnotations);
             }
         };
 
--- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Fri May 09 09:28:47 2014 -0400
@@ -28,7 +28,6 @@
 import java.util.*;
 
 import com.sun.tools.javac.code.*;
-import com.sun.tools.javac.code.Type.AnnotatedType;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.main.Option.PkgInfo;
 import com.sun.tools.javac.tree.*;
@@ -452,7 +451,8 @@
             ClassSymbol outerCacheClass = outerCacheClass();
             this.mapVar = new VarSymbol(STATIC | SYNTHETIC | FINAL,
                                         varName,
-                                        new ArrayType(syms.intType, syms.arrayClass),
+                                        new ArrayType(syms.intType, syms.arrayClass,
+                                                      Type.noAnnotations),
                                         outerCacheClass);
             enterSynthetic(pos, mapVar, outerCacheClass.members());
         }
@@ -493,7 +493,8 @@
                         syms.lengthVar);
             JCExpression mapVarInit = make
                 .NewArray(make.Type(syms.intType), List.of(size), null)
-                .setType(new ArrayType(syms.intType, syms.arrayClass));
+                .setType(new ArrayType(syms.intType, syms.arrayClass,
+                                       Type.noAnnotations));
 
             // try { $SwitchMap$Color[red.ordinal()] = 1; } catch (java.lang.NoSuchFieldError ex) {}
             ListBuffer<JCStatement> stmts = new ListBuffer<>();
@@ -1979,7 +1980,7 @@
                          List.<JCExpression>of(make.Literal(INT, 0).setType(syms.intType)),
                          null);
             newcache.type = new ArrayType(types.erasure(outerCacheClass.type),
-                                          syms.arrayClass);
+                                          syms.arrayClass, Type.noAnnotations);
 
             // forNameSym := java.lang.Class.forName(
             //     String s,boolean init,ClassLoader loader)
@@ -2568,7 +2569,8 @@
         Name valuesName = names.fromString(target.syntheticNameChar() + "VALUES");
         while (tree.sym.members().lookup(valuesName).scope != null) // avoid name clash
             valuesName = names.fromString(valuesName + "" + target.syntheticNameChar());
-        Type arrayType = new ArrayType(types.erasure(tree.type), syms.arrayClass);
+        Type arrayType = new ArrayType(types.erasure(tree.type),
+                                       syms.arrayClass, Type.noAnnotations);
         VarSymbol valuesVar = new VarSymbol(PRIVATE|FINAL|STATIC|SYNTHETIC,
                                             valuesName,
                                             arrayType,
@@ -2841,7 +2843,7 @@
         tree.underlyingType = translate(tree.underlyingType);
         // but maintain type annotations in the type.
         if (tree.type.isAnnotated()) {
-            tree.type = tree.underlyingType.type.unannotatedType().annotatedType(tree.type.getAnnotationMirrors());
+            tree.type = tree.underlyingType.type.annotatedType(tree.type.getAnnotationMirrors());
         } else if (tree.underlyingType.type.isAnnotated()) {
             tree.type = tree.underlyingType.type;
         }
@@ -3145,7 +3147,8 @@
             JCNewArray boxedArgs = make.NewArray(make.Type(varargsElement),
                                                List.<JCExpression>nil(),
                                                elems.toList());
-            boxedArgs.type = new ArrayType(varargsElement, syms.arrayClass);
+            boxedArgs.type = new ArrayType(varargsElement, syms.arrayClass,
+                                           Type.noAnnotations);
             result.append(boxedArgs);
         } else {
             if (args.length() != 1) throw new AssertionError(args);
--- a/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Fri May 09 09:28:47 2014 -0400
@@ -457,7 +457,8 @@
      *  to the symbol table.
      */
     private void addEnumMembers(JCClassDecl tree, Env<AttrContext> env) {
-        JCExpression valuesType = make.Type(new ArrayType(tree.sym.type, syms.arrayClass));
+        JCExpression valuesType = make.Type(new ArrayType(tree.sym.type, syms.arrayClass,
+                                                          Type.noAnnotations));
 
         // public static T[] values() { return ???; }
         JCMethodDecl values = make.
@@ -677,7 +678,7 @@
                 //because varargs is represented in the tree as a
                 //modifier on the parameter declaration, and not as a
                 //distinct type of array node.
-                ArrayType atype = (ArrayType)tree.vartype.type.unannotatedType();
+                ArrayType atype = (ArrayType)tree.vartype.type;
                 tree.vartype.type = atype.makeVarargs();
             }
             Scope enclScope = enter.enterScope(env);
@@ -1255,11 +1256,13 @@
             ClassType ct = (ClassType) sym.type;
             Assert.check(ct.typarams_field.isEmpty());
             if (n == 1) {
-                TypeVar v = new TypeVar(names.fromString("T"), sym, syms.botType);
+                TypeVar v = new TypeVar(names.fromString("T"), sym, syms.botType,
+                                        Type.noAnnotations);
                 ct.typarams_field = ct.typarams_field.prepend(v);
             } else {
                 for (int i = n; i > 0; i--) {
-                    TypeVar v = new TypeVar(names.fromString("T" + i), sym, syms.botType);
+                    TypeVar v = new TypeVar(names.fromString("T" + i), sym,
+                                            syms.botType, Type.noAnnotations);
                     ct.typarams_field = ct.typarams_field.prepend(v);
                 }
             }
@@ -1310,8 +1313,8 @@
         }
         Type mType = new MethodType(argtypes, null, thrown, c);
         Type initType = typarams.nonEmpty() ?
-                new ForAll(typarams, mType) :
-                mType;
+            new ForAll(typarams, mType) :
+            mType;
         MethodSymbol init = new MethodSymbol(flags, names.init,
                 initType, c);
         init.params = createDefaultConstructorParams(make, baseInit, init,
--- a/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Fri May 09 09:28:47 2014 -0400
@@ -2639,7 +2639,7 @@
                             ((ForAll)sym.type).tvars :
                             List.<Type>nil();
                     Type constrType = new ForAll(site.tsym.type.getTypeArguments().appendList(oldParams),
-                            types.createMethodTypeWithReturn(sym.type.asMethodType(), site));
+                                                 types.createMethodTypeWithReturn(sym.type.asMethodType(), site));
                     MethodSymbol newConstr = new MethodSymbol(sym.flags(), names.init, constrType, site.tsym) {
                         @Override
                         public Symbol baseSymbol() {
@@ -3280,7 +3280,7 @@
                 List<Type> typeargtypes, MethodResolutionPhase maxPhase) {
             super(referenceTree, names.init, site, argtypes, typeargtypes, maxPhase);
             if (site.isRaw()) {
-                this.site = new ClassType(site.getEnclosingType(), site.tsym.type.getTypeArguments(), site.tsym);
+                this.site = new ClassType(site.getEnclosingType(), site.tsym.type.getTypeArguments(), site.tsym, site.getAnnotationMirrors());
                 needsInference = true;
             }
         }
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Fri May 09 09:28:47 2014 -0400
@@ -624,18 +624,18 @@
         case '+': {
             sigp++;
             Type t = sigToType();
-            return new WildcardType(t, BoundKind.EXTENDS,
-                                    syms.boundClass);
+            return new WildcardType(t, BoundKind.EXTENDS, syms.boundClass,
+                                    Type.noAnnotations);
         }
         case '*':
             sigp++;
             return new WildcardType(syms.objectType, BoundKind.UNBOUND,
-                                    syms.boundClass);
+                                    syms.boundClass, Type.noAnnotations);
         case '-': {
             sigp++;
             Type t = sigToType();
-            return new WildcardType(t, BoundKind.SUPER,
-                                    syms.boundClass);
+            return new WildcardType(t, BoundKind.SUPER, syms.boundClass,
+                                    Type.noAnnotations);
         }
         case 'B':
             sigp++;
@@ -680,7 +680,8 @@
             return syms.booleanType;
         case '[':
             sigp++;
-            return new ArrayType(sigToType(), syms.arrayClass);
+            return new ArrayType(sigToType(), syms.arrayClass,
+                                 Type.noAnnotations);
         case '(':
             sigp++;
             List<Type> argtypes = sigToTypes(')');
@@ -735,7 +736,8 @@
                 try {
                     return (outer == Type.noType) ?
                             t.erasure(types) :
-                            new ClassType(outer, List.<Type>nil(), t);
+                        new ClassType(outer, List.<Type>nil(), t,
+                                      Type.noAnnotations);
                 } finally {
                     sbp = startSbp;
                 }
@@ -745,7 +747,8 @@
                 ClassSymbol t = syms.enterClass(names.fromUtf(signatureBuffer,
                                                          startSbp,
                                                          sbp - startSbp));
-                outer = new ClassType(outer, sigToTypes('>'), t) {
+                outer = new ClassType(outer, sigToTypes('>'), t,
+                                      Type.noAnnotations) {
                         boolean completed = false;
                         @Override
                         public Type getEnclosingType() {
@@ -808,7 +811,8 @@
                     t = syms.enterClass(names.fromUtf(signatureBuffer,
                                                  startSbp,
                                                  sbp - startSbp));
-                    outer = new ClassType(outer, List.<Type>nil(), t);
+                    outer = new ClassType(outer, List.<Type>nil(), t,
+                                          Type.noAnnotations);
                 }
                 signatureBuffer[sbp++] = (byte)'$';
                 continue;
@@ -871,7 +875,8 @@
         Name name = names.fromUtf(signature, start, sigp - start);
         TypeVar tvar;
         if (sigEnterPhase) {
-            tvar = new TypeVar(name, currentOwner, syms.botType);
+            tvar = new TypeVar(name, currentOwner, syms.botType,
+                               Type.noAnnotations);
             typevars.enter(tvar.tsym);
         } else {
             tvar = (TypeVar)findTypeVar(name);
@@ -910,7 +915,8 @@
                 // we don't know for sure if this owner is correct.  It could
                 // be a method and there is no way to tell before reading the
                 // enclosing method attribute.
-                TypeVar t = new TypeVar(name, currentOwner, syms.botType);
+                TypeVar t = new TypeVar(name, currentOwner, syms.botType,
+                                        Type.noAnnotations);
                 missingTypeVariables = missingTypeVariables.prepend(t);
                 // System.err.println("Missing type var " + name);
                 return t;
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Fri May 09 09:28:47 2014 -0400
@@ -286,7 +286,6 @@
          */
         @Override
         public void assembleSig(Type type) {
-            type = type.unannotatedType();
             switch (type.getTag()) {
                 case UNINITIALIZED_THIS:
                 case UNINITIALIZED_OBJECT:
@@ -354,7 +353,7 @@
         } else if (t.hasTag(ARRAY)) {
             return typeSig(types.erasure(t));
         } else {
-            throw new AssertionError("xClassName");
+            throw new AssertionError("xClassName expects class or array type, got " + t);
         }
     }
 
--- a/src/share/classes/com/sun/tools/javac/jvm/Code.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/Code.java	Fri May 09 09:28:47 2014 -0400
@@ -928,7 +928,7 @@
         if (o instanceof Pool.MethodHandle) return syms.methodHandleType;
         if (o instanceof UniqueType) return typeForPool(((UniqueType)o).type);
         if (o instanceof Type) {
-            Type ty = ((Type)o).unannotatedType();
+            Type ty = (Type) o;
 
             if (ty instanceof Type.ArrayType) return syms.classType;
             if (ty instanceof Type.MethodType) return syms.methodTypeType;
@@ -1579,8 +1579,8 @@
 
     /** Add a catch clause to code.
      */
-    public void addCatch(
-        char startPc, char endPc, char handlerPc, char catchType) {
+    public void addCatch(char startPc, char endPc,
+                         char handlerPc, char catchType) {
             catchInfo.append(new char[]{startPc, endPc, handlerPc, catchType});
         }
 
@@ -2149,7 +2149,7 @@
             for (Attribute.TypeCompound ta : lv.sym.getRawTypeAttributes()) {
                 TypeAnnotationPosition p = ta.position;
                 if (p.hasCatchType()) {
-                    final int idx = findExceptionIndex(p.getCatchType());
+                    final int idx = findExceptionIndex(p);
                     if (idx == -1)
                         Assert.error("Could not find exception index for type annotation " +
                                      ta + " on exception parameter");
@@ -2159,14 +2159,17 @@
         }
     }
 
-    private int findExceptionIndex(int catchType) {
+    private int findExceptionIndex(TypeAnnotationPosition p) {
+        final int catchType = p.getCatchType();
+        final int startPos = p.getStartPos();
+        final int len = catchInfo.length();
         List<char[]> iter = catchInfo.toList();
-        int len = catchInfo.length();
         for (int i = 0; i < len; ++i) {
             char[] catchEntry = iter.head;
             iter = iter.tail;
-            char ct = catchEntry[3];
-            if (catchType == ct) {
+            int ct = catchEntry[3];
+            int sp = catchEntry[0];
+            if (catchType == ct && sp == startPos) {
                 return i;
             }
         }
--- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Fri May 09 09:28:47 2014 -0400
@@ -317,10 +317,6 @@
     int makeRef(DiagnosticPosition pos, Type type) {
         checkDimension(pos, type);
         if (type.isAnnotated()) {
-            // Treat annotated types separately - we don't want
-            // to collapse all of them - at least for annotated
-            // exceptions.
-            // TODO: review this.
             return pool.put((Object)type);
         } else {
             return pool.put(type.hasTag(CLASS) ? (Object)type.tsym : (Object)type);
@@ -1647,7 +1643,7 @@
                         if (subCatch.type.isAnnotated()) {
                             for (Attribute.TypeCompound tc :
                                      subCatch.type.getAnnotationMirrors()) {
-                                tc.position.setCatchType(catchType);
+                                tc.position.setCatchInfo(catchType, startpc);
                             }
                         }
                     }
@@ -1664,7 +1660,7 @@
                         if (subCatch.type.isAnnotated()) {
                             for (Attribute.TypeCompound tc :
                                      subCatch.type.getAnnotationMirrors()) {
-                                tc.position.setCatchType(catchType);
+                                tc.position.setCatchInfo(catchType, startpc);
                             }
                         }
                     }
--- a/src/share/classes/com/sun/tools/javac/jvm/JNIWriter.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/JNIWriter.java	Fri May 09 09:28:47 2014 -0400
@@ -674,11 +674,6 @@
         }
 
         @Override
-        public R visitAnnotatedType(Type.AnnotatedType t, P p) {
-            return defaultAction(t, p);
-        }
-
-        @Override
         public R visitType(Type t, P p) {
             return defaultAction(t, p);
         }
--- a/src/share/classes/com/sun/tools/javac/jvm/Pool.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/Pool.java	Fri May 09 09:28:47 2014 -0400
@@ -102,10 +102,11 @@
      */
     public int put(Object value) {
         value = makePoolValue(value);
-//      assert !(value instanceof Type.TypeVar);
+        Assert.check(!(value instanceof Type.TypeVar));
+        Assert.check(!(value instanceof Types.UniqueType &&
+                       ((UniqueType) value).type instanceof Type.TypeVar));
         Integer index = indices.get(value);
         if (index == null) {
-//          System.err.println("put " + value + " " + value.getClass());//DEBUG
             index = pp;
             indices.put(value, index);
             pool = ArrayUtils.ensureCapacity(pool, pp);
--- a/src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java	Fri May 09 09:28:47 2014 -0400
@@ -26,6 +26,7 @@
 package com.sun.tools.javac.jvm;
 
 import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.util.List;
 
 import static com.sun.tools.javac.code.TypeTag.UNINITIALIZED_OBJECT;
 import static com.sun.tools.javac.code.TypeTag.UNINITIALIZED_THIS;
@@ -41,19 +42,27 @@
 class UninitializedType extends Type.DelegatedType {
 
     public static UninitializedType uninitializedThis(Type qtype) {
-        return new UninitializedType(UNINITIALIZED_THIS, qtype, -1);
+        return new UninitializedType(UNINITIALIZED_THIS, qtype, -1,
+                                     qtype.getAnnotationMirrors());
     }
 
     public static UninitializedType uninitializedObject(Type qtype, int offset) {
-        return new UninitializedType(UNINITIALIZED_OBJECT, qtype, offset);
+        return new UninitializedType(UNINITIALIZED_OBJECT, qtype, offset,
+                                     qtype.getAnnotationMirrors());
     }
 
     public final int offset; // PC where allocation took place
-    private UninitializedType(TypeTag tag, Type qtype, int offset) {
-        super(tag, qtype);
+    private UninitializedType(TypeTag tag, Type qtype, int offset,
+                              List<Attribute.TypeCompound> typeAnnotations) {
+        super(tag, qtype, typeAnnotations);
         this.offset = offset;
     }
 
+    @Override
+    public UninitializedType annotatedType(List<Attribute.TypeCompound> typeAnnotations) {
+        return new UninitializedType(tag, qtype, offset, typeAnnotations);
+    }
+
     Type initializedType() {
         return qtype;
     }
--- a/src/share/classes/com/sun/tools/javac/model/JavacTypes.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/model/JavacTypes.java	Fri May 09 09:28:47 2014 -0400
@@ -168,7 +168,8 @@
         case PACKAGE:
             throw new IllegalArgumentException(componentType.toString());
         }
-        return new Type.ArrayType((Type) componentType, syms.arrayClass);
+        return new Type.ArrayType((Type) componentType, syms.arrayClass,
+                                  Type.noAnnotations);
     }
 
     public WildcardType getWildcardType(TypeMirror extendsBound,
@@ -193,7 +194,8 @@
         case DECLARED:
         case ERROR:
         case TYPEVAR:
-            return new Type.WildcardType(bound, bkind, syms.boundClass);
+            return new Type.WildcardType(bound, bkind, syms.boundClass,
+                                         Type.noAnnotations);
         default:
             throw new IllegalArgumentException(bound.toString());
         }
@@ -243,7 +245,8 @@
             }
             // TODO: Would like a way to check that type args match formals.
 
-            return (DeclaredType) new Type.ClassType(outer, targs.toList(), sym);
+            return (DeclaredType) new Type.ClassType(outer, targs.toList(), sym,
+                                                     Type.noAnnotations);
         }
 
     /**
--- a/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Fri May 09 09:28:47 2014 -0400
@@ -1089,7 +1089,8 @@
                 for (ClassSymbol cs : symtab.classes.values()) {
                     if (cs.classfile != null || cs.kind == Kinds.ERR) {
                         cs.reset();
-                        cs.type = new ClassType(cs.type.getEnclosingType(), null, cs);
+                        cs.type = new ClassType(cs.type.getEnclosingType(),
+                                                null, cs, Type.noAnnotations);
                         if (cs.completer == null) {
                             cs.completer = initialCompleter;
                         }
--- a/src/share/classes/com/sun/tools/javadoc/AnnotatedTypeImpl.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javadoc/AnnotatedTypeImpl.java	Fri May 09 09:28:47 2014 -0400
@@ -65,7 +65,7 @@
 
     @Override
     public com.sun.javadoc.Type underlyingType() {
-        return TypeMaker.getType(env, type.unannotatedType(), true, false);
+        return TypeMaker.getType(env, type, true, false);
     }
 
     @Override
--- a/src/share/classes/com/sun/tools/javadoc/TypeMaker.java	Fri May 09 08:52:57 2014 -0700
+++ b/src/share/classes/com/sun/tools/javadoc/TypeMaker.java	Fri May 09 09:28:47 2014 -0400
@@ -140,9 +140,6 @@
      */
     static String getTypeString(DocEnv env, Type t, boolean full) {
         // TODO: should annotations be included here?
-        if (t.isAnnotated()) {
-            t = t.unannotatedType();
-        }
         switch (t.getTag()) {
         case ARRAY:
             StringBuilder s = new StringBuilder();
--- a/test/tools/javac/annotations/typeAnnotations/referenceinfos/Driver.java	Fri May 09 08:52:57 2014 -0700
+++ b/test/tools/javac/annotations/typeAnnotations/referenceinfos/Driver.java	Fri May 09 09:28:47 2014 -0400
@@ -42,7 +42,7 @@
 
 public class Driver {
 
-    private static final PrintStream out = System.out;
+    private static final PrintStream out = System.err;
 
     public static void main(String[] args) throws Exception {
         if (args.length == 0 || args.length > 1)
--- a/test/tools/javac/types/TypeHarness.java	Fri May 09 08:52:57 2014 -0700
+++ b/test/tools/javac/types/TypeHarness.java	Fri May 09 09:28:47 2014 -0400
@@ -255,7 +255,8 @@
 
         public ClassType Class(long flags, Type... typeArgs) {
             ClassSymbol csym = new ClassSymbol(flags, syntheticName(), predef.noSymbol);
-            csym.type = new ClassType(Type.noType, List.from(typeArgs), csym);
+            csym.type = new ClassType(Type.noType, List.from(typeArgs), csym,
+                                      Type.noAnnotations);
             ((ClassType)csym.type).supertype_field = predef.objectType;
             return (ClassType)csym.type;
         }
@@ -301,7 +302,7 @@
         }
 
         public ArrayType Array(Type elemType) {
-            return new ArrayType(elemType, predef.arrayClass);
+            return new ArrayType(elemType, predef.arrayClass, Type.noAnnotations);
         }
 
         public TypeVar TypeVariable() {
@@ -310,16 +311,16 @@
 
         public TypeVar TypeVariable(Type bound) {
             TypeSymbol tvsym = new TypeVariableSymbol(0, syntheticName(), null, predef.noSymbol);
-            tvsym.type = new TypeVar(tvsym, bound, null);
+            tvsym.type = new TypeVar(tvsym, bound, null, Type.noAnnotations);
             return (TypeVar)tvsym.type;
         }
 
         public WildcardType Wildcard(BoundKind bk, Type bound) {
-            return new WildcardType(bound, bk, predef.boundClass);
+            return new WildcardType(bound, bk, predef.boundClass, Type.noAnnotations);
         }
 
         public CapturedType CapturedVariable(Type upper, Type lower) {
-            return new CapturedType(syntheticName(), predef.noSymbol, upper, lower, null);
+            return new CapturedType(syntheticName(), predef.noSymbol, upper, lower, null, Type.noAnnotations);
         }
 
         public ClassType Intersection(Type classBound, Type... intfBounds) {