changeset 3188:d607ae60772d

8033004: Make base TypeAnnotationPosition data immutable, create better methods for creating base TypeAnnotationPositions Summary: First of a series of major fixes to type annotations; cleans up interface with TypeAnnotationPosition Reviewed-by: jjg
author emc
date Mon, 03 Feb 2014 17:19:15 -0500
parents 6c96a2941e60
children b04cc30348a9
files src/share/classes/com/sun/tools/javac/code/SymbolMetadata.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/comp/Annotate.java src/share/classes/com/sun/tools/javac/jvm/ClassReader.java src/share/classes/com/sun/tools/javac/tree/JCTree.java
diffstat 6 files changed, 1311 insertions(+), 296 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java	Mon Feb 03 17:19:15 2014 -0500
@@ -425,11 +425,15 @@
         private final List<T> placeholderFor;
         private final Symbol on;
 
-        public Placeholder(Annotate.AnnotateRepeatedContext<T> ctx, List<T> placeholderFor, Symbol on) {
+        public Placeholder(Annotate.AnnotateRepeatedContext<T> ctx,
+                           List<T> placeholderFor, Symbol on) {
             super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),
-                    ctx.isTypeCompound ?
-                            ((Attribute.TypeCompound)placeholderFor.head).position :
-                                new TypeAnnotationPosition());
+                  ctx.isTypeCompound ?
+                  ((Attribute.TypeCompound)placeholderFor.head).position :
+                  // TODO: Eventually, we will need to get rid of this
+                  // use of unknown, either by using null, or by
+                  // throwing an assertion failure here.
+                  TypeAnnotationPosition.unknown);
             this.ctx = ctx;
             this.placeholderFor = placeholderFor;
             this.on = on;
--- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Mon Feb 03 17:19:15 2014 -0500
@@ -119,13 +119,20 @@
         }
     }
 
-    public TargetType type = TargetType.UNKNOWN;
+    public static final List<TypePathEntry> emptyPath = List.nil();
+
+    // NOTE: All of these will be converted to final fields eventually.
+
+    public final TargetType type;
 
     // For generic/array types.
-    public List<TypePathEntry> location = List.nil();
+
+    // This field is in the process of being made final.  Do not
+    // introduce new mutations.
+    public List<TypePathEntry> location;
 
     // Tree position.
-    public int pos = -1;
+    public final int pos;
 
     // For type casts, type tests, new, locals (as start_pc),
     // and method and constructor reference type arguments.
@@ -138,13 +145,17 @@
     public int[] lvarIndex = null;
 
     // For type parameter bound
-    public int bound_index = Integer.MIN_VALUE;
+    public final int bound_index;
 
     // For type parameter and method parameter
-    public int parameter_index = Integer.MIN_VALUE;
+    public final int parameter_index;
 
     // For class extends, implements, and throws clauses
-    public int type_index = Integer.MIN_VALUE;
+
+    // This field is effectively final.  However, it needs to be
+    // modified by Gen for the time being.  Do not introduce new
+    // mutations.
+    public int type_index;
 
     // For exception parameters, index into exception table.
     // In com.sun.tools.javac.jvm.Gen.genCatch we first set the type_index
@@ -156,9 +167,10 @@
     // If this type annotation is within a lambda expression,
     // store a pointer to the lambda expression tree in order
     // to allow a later translation to the right method.
-    public JCLambda onLambda = null;
+    public final JCLambda onLambda;
 
-    public TypeAnnotationPosition() {}
+    // NOTE: This constructor will eventually go away, and be replaced
+    // by static builder methods.
 
     @Override
     public String toString() {
@@ -323,4 +335,847 @@
         }
         return loc.toList();
     }
+
+    // These methods are the new preferred way to create
+    // TypeAnnotationPositions
+
+    // Never make this a public constructor without creating a builder.
+    private TypeAnnotationPosition(final TargetType ttype,
+                                   final int pos,
+                                   final int parameter_index,
+                                   final JCLambda onLambda,
+                                   final int type_index,
+                                   final int bound_index,
+                                   final List<TypePathEntry> location) {
+        Assert.checkNonNull(location);
+        this.type = ttype;
+        this.pos = pos;
+        this.parameter_index = parameter_index;
+        this.onLambda = onLambda;
+        this.type_index = type_index;
+        this.bound_index = bound_index;
+        this.location = location;
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method return.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodReturn(final List<TypePathEntry> location,
+                     final JCLambda onLambda,
+                     final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_RETURN, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method return.
+     *
+     * @param location The type path.
+     */
+    public static TypeAnnotationPosition
+        methodReturn(final List<TypePathEntry> location) {
+        return methodReturn(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method return.
+     *
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition methodReturn(final int pos) {
+        return methodReturn(emptyPath, null, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method receiver.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodReceiver(final List<TypePathEntry> location,
+                     final JCLambda onLambda,
+                     final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_RECEIVER, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method receiver.
+     *
+     * @param location The type path.
+     */
+    public static TypeAnnotationPosition
+        methodReceiver(final List<TypePathEntry> location) {
+        return methodReceiver(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method receiver.
+     *
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition methodReceiver(final int pos) {
+        return methodReceiver(emptyPath, null, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method formal parameter.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this parameter.
+     * @param index The index of the parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodParameter(final List<TypePathEntry> location,
+                        final JCLambda onLambda,
+                        final int parameter_index,
+                        final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_FORMAL_PARAMETER,
+                                          pos, parameter_index, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method formal parameter.
+     *
+     * @param onLambda The lambda for this parameter.
+     * @param index The index of the parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodParameter(final JCLambda onLambda,
+                        final int parameter_index,
+                        final int pos) {
+        return methodParameter(emptyPath, onLambda,
+                               parameter_index, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method formal parameter.
+     *
+     * @param index The index of the parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodParameter(final int parameter_index,
+                        final int pos) {
+        return methodParameter(null, parameter_index, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method formal parameter.
+     *
+     * @param location The type path.
+     * @param index The index of the parameter.
+     */
+    public static TypeAnnotationPosition
+        methodParameter(final List<TypePathEntry> location,
+                        final int parameter_index) {
+        return methodParameter(location, null, parameter_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method reference.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this method reference.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodRef(final List<TypePathEntry> location,
+                  final JCLambda onLambda,
+                  final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_REFERENCE, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method reference.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this method reference.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodRef(final List<TypePathEntry> location) {
+        return methodRef(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor reference.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this constructor reference.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        constructorRef(final List<TypePathEntry> location,
+                       final JCLambda onLambda,
+                       final int pos) {
+        return new TypeAnnotationPosition(TargetType.CONSTRUCTOR_REFERENCE, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor reference.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this constructor reference.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        constructorRef(final List<TypePathEntry> location) {
+        return constructorRef(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a field.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        field(final List<TypePathEntry> location,
+              final JCLambda onLambda,
+              final int pos) {
+        return new TypeAnnotationPosition(TargetType.FIELD, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a field.
+     *
+     * @param location The type path.
+     */
+    public static TypeAnnotationPosition
+        field(final List<TypePathEntry> location) {
+        return field(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a field.
+     *
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition field(final int pos) {
+        return field(emptyPath, null, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a local variable.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        localVariable(final List<TypePathEntry> location,
+                      final JCLambda onLambda,
+                      final int pos) {
+        return new TypeAnnotationPosition(TargetType.LOCAL_VARIABLE, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a local variable.
+     *
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        localVariable(final JCLambda onLambda,
+                      final int pos) {
+        return localVariable(emptyPath, onLambda, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a local variable.
+     *
+     * @param location The type path.
+     */
+    public static TypeAnnotationPosition
+        localVariable(final List<TypePathEntry> location) {
+        return localVariable(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for an exception parameter.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        exceptionParameter(final List<TypePathEntry> location,
+                           final JCLambda onLambda,
+                           final int pos) {
+        return new TypeAnnotationPosition(TargetType.EXCEPTION_PARAMETER, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for an exception parameter.
+     *
+     * @param onLambda The lambda for this parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        exceptionParameter(final JCLambda onLambda,
+                           final int pos) {
+        return exceptionParameter(emptyPath, onLambda, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for an exception parameter.
+     *
+     * @param location The type path.
+     */
+    public static TypeAnnotationPosition
+        exceptionParameter(final List<TypePathEntry> location) {
+        return exceptionParameter(location, null, -1);
+    }
+
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a resource variable.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        resourceVariable(final List<TypePathEntry> location,
+                         final JCLambda onLambda,
+                         final int pos) {
+        return new TypeAnnotationPosition(TargetType.RESOURCE_VARIABLE, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a resource variable.
+     *
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        resourceVariable(final JCLambda onLambda,
+                         final int pos) {
+        return resourceVariable(emptyPath, onLambda, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a resource variable.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        resourceVariable(final List<TypePathEntry> location) {
+        return resourceVariable(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a new.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        newObj(final List<TypePathEntry> location,
+               final JCLambda onLambda,
+               final int pos) {
+        return new TypeAnnotationPosition(TargetType.NEW, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a new.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition newObj(final int pos) {
+        return newObj(emptyPath, null, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a new.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        newObj(final List<TypePathEntry> location) {
+        return newObj(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a class extension.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index of the interface.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        classExtends(final List<TypePathEntry> location,
+                     final JCLambda onLambda,
+                     final int type_index,
+                     final int pos) {
+        return new TypeAnnotationPosition(TargetType.CLASS_EXTENDS, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a class extension.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index of the interface.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        classExtends(final List<TypePathEntry> location,
+                     final JCLambda onLambda,
+                     final int pos) {
+        return classExtends(location, onLambda, -1, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a class extension.
+     *
+     * @param location The type path.
+     * @param type_index The index of the interface.
+     */
+    public static TypeAnnotationPosition
+        classExtends(final List<TypePathEntry> location,
+                     final int type_index) {
+        return classExtends(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a class extension.
+     *
+     * @param type_index The index of the interface.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition classExtends(final int type_index,
+                                                      final int pos) {
+        return classExtends(emptyPath, null, type_index, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a class extension.
+     *
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition classExtends(final int pos) {
+        return classExtends(-1, pos);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for an instanceof.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        instanceOf(final List<TypePathEntry> location,
+                   final JCLambda onLambda,
+                   final int pos) {
+        return new TypeAnnotationPosition(TargetType.INSTANCEOF, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+    /**
+     * Create a {@code TypeAnnotationPosition} for an instanceof.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        instanceOf(final List<TypePathEntry> location) {
+        return instanceOf(location, null, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type cast.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index into an intersection type.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        typeCast(final List<TypePathEntry> location,
+                 final JCLambda onLambda,
+                 final int type_index,
+                 final int pos) {
+        return new TypeAnnotationPosition(TargetType.CAST, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type cast.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index into an intersection type.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        typeCast(final List<TypePathEntry> location,
+                 final int type_index) {
+        return typeCast(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method
+     * invocation type argument.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index of the type argument.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodInvocationTypeArg(final List<TypePathEntry> location,
+                                final JCLambda onLambda,
+                                final int type_index,
+                                final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_INVOCATION_TYPE_ARGUMENT,
+                                          pos, Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method
+     * invocation type argument.
+     *
+     * @param location The type path.
+     * @param type_index The index of the type argument.
+     */
+    public static TypeAnnotationPosition
+        methodInvocationTypeArg(final List<TypePathEntry> location,
+                                final int type_index) {
+        return methodInvocationTypeArg(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor
+     * invocation type argument.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index of the type argument.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        constructorInvocationTypeArg(final List<TypePathEntry> location,
+                                     final JCLambda onLambda,
+                                     final int type_index,
+                                     final int pos) {
+        return new TypeAnnotationPosition(TargetType.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT,
+                                          pos, Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor
+     * invocation type argument.
+     *
+     * @param location The type path.
+     * @param type_index The index of the type argument.
+     */
+    public static TypeAnnotationPosition
+        constructorInvocationTypeArg(final List<TypePathEntry> location,
+                                     final int type_index) {
+        return constructorInvocationTypeArg(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type parameter.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        typeParameter(final List<TypePathEntry> location,
+                      final JCLambda onLambda,
+                      final int parameter_index,
+                      final int pos) {
+        return new TypeAnnotationPosition(TargetType.CLASS_TYPE_PARAMETER, pos,
+                                          parameter_index, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type parameter.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        typeParameter(final List<TypePathEntry> location,
+                      final int parameter_index) {
+        return typeParameter(location, null, parameter_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method type parameter.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type parameter.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodTypeParameter(final List<TypePathEntry> location,
+                            final JCLambda onLambda,
+                            final int parameter_index,
+                            final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_TYPE_PARAMETER,
+                                          pos, parameter_index, onLambda,
+                                          Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method type parameter.
+     *
+     * @param location The type path.
+     * @param parameter_index The index of the type parameter.
+     */
+    public static TypeAnnotationPosition
+        methodTypeParameter(final List<TypePathEntry> location,
+                            final int parameter_index) {
+        return methodTypeParameter(location, null, parameter_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a throws clause.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param type_index The index of the exception.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodThrows(final List<TypePathEntry> location,
+                     final JCLambda onLambda,
+                     final int type_index,
+                     final int pos) {
+        return new TypeAnnotationPosition(TargetType.THROWS, pos,
+                                          Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a throws clause.
+     *
+     * @param location The type path.
+     * @param type_index The index of the exception.
+     */
+    public static TypeAnnotationPosition
+        methodThrows(final List<TypePathEntry> location,
+                     final int type_index) {
+        return methodThrows(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method reference
+     * type argument.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type argument.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodRefTypeArg(final List<TypePathEntry> location,
+                         final JCLambda onLambda,
+                         final int type_index,
+                         final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_REFERENCE_TYPE_ARGUMENT,
+                                          pos, Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method reference
+     * type argument.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type argument.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodRefTypeArg(final List<TypePathEntry> location,
+                         final int type_index) {
+        return methodRefTypeArg(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor reference
+     * type argument.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type argument.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        constructorRefTypeArg(final List<TypePathEntry> location,
+                              final JCLambda onLambda,
+                              final int type_index,
+                              final int pos) {
+        return new TypeAnnotationPosition(TargetType.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT,
+                                          pos, Integer.MIN_VALUE, onLambda,
+                                          type_index, Integer.MIN_VALUE,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a constructor reference
+     * type argument.
+     *
+     * @param location The type path.
+     * @param parameter_index The index of the type argument.
+     */
+    public static TypeAnnotationPosition
+        constructorRefTypeArg(final List<TypePathEntry> location,
+                              final int type_index) {
+        return constructorRefTypeArg(location, null, type_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type parameter bound.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type parameter.
+     * @param bound_index The index of the type parameter bound.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        typeParameterBound(final List<TypePathEntry> location,
+                           final JCLambda onLambda,
+                           final int parameter_index,
+                           final int bound_index,
+                           final int pos) {
+        return new TypeAnnotationPosition(TargetType.CLASS_TYPE_PARAMETER_BOUND,
+                                          pos, parameter_index, onLambda,
+                                          Integer.MIN_VALUE, bound_index,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a type parameter bound.
+     *
+     * @param location The type path.
+     * @param parameter_index The index of the type parameter.
+     * @param bound_index The index of the type parameter bound.
+     */
+    public static TypeAnnotationPosition
+        typeParameterBound(final List<TypePathEntry> location,
+                           final int parameter_index,
+                           final int bound_index) {
+        return typeParameterBound(location, null, parameter_index,
+                                  bound_index, -1);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method type
+     * parameter bound.
+     *
+     * @param location The type path.
+     * @param onLambda The lambda for this variable.
+     * @param parameter_index The index of the type parameter.
+     * @param bound_index The index of the type parameter bound.
+     * @param pos The position from the associated tree node.
+     */
+    public static TypeAnnotationPosition
+        methodTypeParameterBound(final List<TypePathEntry> location,
+                                 final JCLambda onLambda,
+                                 final int parameter_index,
+                                 final int bound_index,
+                                 final int pos) {
+        return new TypeAnnotationPosition(TargetType.METHOD_TYPE_PARAMETER_BOUND,
+                                          pos, parameter_index, onLambda,
+                                          Integer.MIN_VALUE, bound_index,
+                                          location);
+    }
+
+    /**
+     * Create a {@code TypeAnnotationPosition} for a method type
+     * parameter bound.
+     *
+     * @param location The type path.
+     * @param parameter_index The index of the type parameter.
+     * @param bound_index The index of the type parameter bound.
+     */
+    public static TypeAnnotationPosition
+        methodTypeParameterBound(final List<TypePathEntry> location,
+                                 final int parameter_index,
+                                 final int bound_index) {
+        return methodTypeParameterBound(location, null, parameter_index,
+                                        bound_index, -1);
+    }
+
+    // Consider this deprecated on arrival.  We eventually want to get
+    // rid of this value altogether.  Do not use it for anything new.
+    public static final TypeAnnotationPosition unknown =
+        new TypeAnnotationPosition(TargetType.UNKNOWN, -1,
+                                   Integer.MIN_VALUE, null,
+                                   Integer.MIN_VALUE, Integer.MIN_VALUE,
+                                   emptyPath);
 }
--- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Mon Feb 03 17:19:15 2014 -0500
@@ -663,8 +663,15 @@
          * type annotations: determine the type annotation positions.
          */
 
-        private void resolveFrame(JCTree tree, JCTree frame,
-                List<JCTree> path, TypeAnnotationPosition p) {
+        // This method is considered deprecated, and will be removed
+        // in the near future.  Don't use it for anything new.
+        private TypeAnnotationPosition
+            resolveFrame(JCTree tree,
+                         JCTree frame,
+                         List<JCTree> path,
+                         JCLambda currentLambda,
+                         int outer_type_index,
+                         ListBuffer<TypePathEntry> location) {
             /*
             System.out.println("Resolving tree: " + tree + " kind: " + tree.getKind());
             System.out.println("    Framing tree: " + frame + " kind: " + frame.getKind());
@@ -675,87 +682,101 @@
 
             switch (frame.getKind()) {
                 case TYPE_CAST:
-                    JCTypeCast frameTC = (JCTypeCast) frame;
-                    p.type = TargetType.CAST;
-                    if (frameTC.clazz.hasTag(Tag.TYPEINTERSECTION)) {
-                        // This case was already handled by INTERSECTION_TYPE
-                    } else {
-                        p.type_index = 0;
-                    }
-                    p.pos = frame.pos;
-                    return;
+                    return TypeAnnotationPosition.typeCast(location.toList(),
+                                                           currentLambda,
+                                                           outer_type_index,
+                                                           frame.pos);
 
                 case INSTANCE_OF:
-                    p.type = TargetType.INSTANCEOF;
-                    p.pos = frame.pos;
-                    return;
+                    return TypeAnnotationPosition.instanceOf(location.toList(),
+                                                             currentLambda,
+                                                             frame.pos);
 
                 case NEW_CLASS:
-                    JCNewClass frameNewClass = (JCNewClass) frame;
+                    final JCNewClass frameNewClass = (JCNewClass) frame;
                     if (frameNewClass.def != null) {
                         // Special handling for anonymous class instantiations
-                        JCClassDecl frameClassDecl = frameNewClass.def;
+                        final JCClassDecl frameClassDecl = frameNewClass.def;
                         if (frameClassDecl.extending == tree) {
-                            p.type = TargetType.CLASS_EXTENDS;
-                            p.type_index = -1;
+                            return TypeAnnotationPosition
+                                .classExtends(location.toList(), currentLambda,
+                                              frame.pos);
                         } else if (frameClassDecl.implementing.contains(tree)) {
-                            p.type = TargetType.CLASS_EXTENDS;
-                            p.type_index = frameClassDecl.implementing.indexOf(tree);
+                            final int type_index =
+                                frameClassDecl.implementing.indexOf(tree);
+                            return TypeAnnotationPosition
+                                .classExtends(location.toList(), currentLambda,
+                                              type_index, frame.pos);
                         } else {
                             // In contrast to CLASS below, typarams cannot occur here.
-                            Assert.error("Could not determine position of tree " + tree +
-                                    " within frame " + frame);
+                            throw new AssertionError("Could not determine position of tree " + tree +
+                                                     " within frame " + frame);
                         }
                     } else if (frameNewClass.typeargs.contains(tree)) {
-                        p.type = TargetType.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT;
-                        p.type_index = frameNewClass.typeargs.indexOf(tree);
+                        final int type_index =
+                            frameNewClass.typeargs.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .constructorInvocationTypeArg(location.toList(),
+                                                          currentLambda,
+                                                          type_index,
+                                                          frame.pos);
                     } else {
-                        p.type = TargetType.NEW;
+                        return TypeAnnotationPosition
+                            .newObj(location.toList(), currentLambda,
+                                    frame.pos);
                     }
-                    p.pos = frame.pos;
-                    return;
 
                 case NEW_ARRAY:
-                    p.type = TargetType.NEW;
-                    p.pos = frame.pos;
-                    return;
+                    return TypeAnnotationPosition
+                        .newObj(location.toList(), currentLambda, frame.pos);
 
                 case ANNOTATION_TYPE:
                 case CLASS:
                 case ENUM:
                 case INTERFACE:
-                    p.pos = frame.pos;
                     if (((JCClassDecl)frame).extending == tree) {
-                        p.type = TargetType.CLASS_EXTENDS;
-                        p.type_index = -1;
+                        return TypeAnnotationPosition
+                            .classExtends(location.toList(), currentLambda,
+                                          frame.pos);
                     } else if (((JCClassDecl)frame).implementing.contains(tree)) {
-                        p.type = TargetType.CLASS_EXTENDS;
-                        p.type_index = ((JCClassDecl)frame).implementing.indexOf(tree);
+                        final int type_index =
+                            ((JCClassDecl)frame).implementing.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .classExtends(location.toList(), currentLambda,
+                                          type_index, frame.pos);
                     } else if (((JCClassDecl)frame).typarams.contains(tree)) {
-                        p.type = TargetType.CLASS_TYPE_PARAMETER;
-                        p.parameter_index = ((JCClassDecl)frame).typarams.indexOf(tree);
+                        final int parameter_index =
+                            ((JCClassDecl)frame).typarams.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .typeParameter(location.toList(), currentLambda,
+                                           parameter_index, frame.pos);
                     } else {
-                        Assert.error("Could not determine position of tree " + tree +
-                                " within frame " + frame);
+                        throw new AssertionError("Could not determine position of tree " +
+                                                 tree + " within frame " + frame);
                     }
-                    return;
 
                 case METHOD: {
-                    JCMethodDecl frameMethod = (JCMethodDecl) frame;
-                    p.pos = frame.pos;
+                    final JCMethodDecl frameMethod = (JCMethodDecl) frame;
                     if (frameMethod.thrown.contains(tree)) {
-                        p.type = TargetType.THROWS;
-                        p.type_index = frameMethod.thrown.indexOf(tree);
+                        final int type_index = frameMethod.thrown.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .methodThrows(location.toList(), currentLambda,
+                                          type_index, frame.pos);
                     } else if (frameMethod.restype == tree) {
-                        p.type = TargetType.METHOD_RETURN;
+                        return TypeAnnotationPosition
+                            .methodReturn(location.toList(), currentLambda,
+                                          frame.pos);
                     } else if (frameMethod.typarams.contains(tree)) {
-                        p.type = TargetType.METHOD_TYPE_PARAMETER;
-                        p.parameter_index = frameMethod.typarams.indexOf(tree);
+                        final int parameter_index =
+                            frameMethod.typarams.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .methodTypeParameter(location.toList(),
+                                                 currentLambda,
+                                                 parameter_index, frame.pos);
                     } else {
-                        Assert.error("Could not determine position of tree " + tree +
-                                " within frame " + frame);
+                        throw new AssertionError("Could not determine position of tree " + tree +
+                                                 " within frame " + frame);
                     }
-                    return;
                 }
 
                 case PARAMETERIZED_TYPE: {
@@ -766,25 +787,30 @@
                     } else if (((JCTypeApply)frame).arguments.contains(tree)) {
                         JCTypeApply taframe = (JCTypeApply) frame;
                         int arg = taframe.arguments.indexOf(tree);
-                        p.location = p.location.prepend(new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT, arg));
+                        location = location.prepend(
+                            new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT,
+                                              arg));
 
                         Type typeToUse;
-                        if (newPath.tail != null && newPath.tail.head.hasTag(Tag.NEWCLASS)) {
-                            // If we are within an anonymous class instantiation, use its type,
-                            // because it contains a correctly nested type.
+                        if (newPath.tail != null &&
+                            newPath.tail.head.hasTag(Tag.NEWCLASS)) {
+                            // If we are within an anonymous class
+                            // instantiation, use its type, because it
+                            // contains a correctly nested type.
                             typeToUse = newPath.tail.head.type;
                         } else {
                             typeToUse = taframe.type;
                         }
 
-                        locateNestedTypes(typeToUse, p);
+                        location = locateNestedTypes(typeToUse, location);
                     } else {
-                        Assert.error("Could not determine type argument position of tree " + tree +
-                                " within frame " + frame);
+                        throw new AssertionError("Could not determine type argument position of tree " + tree +
+                                                 " within frame " + frame);
                     }
 
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index, location);
                 }
 
                 case MEMBER_REFERENCE: {
@@ -793,117 +819,140 @@
                     if (mrframe.expr == tree) {
                         switch (mrframe.mode) {
                         case INVOKE:
-                            p.type = TargetType.METHOD_REFERENCE;
-                            break;
+                            return TypeAnnotationPosition
+                                .methodRef(location.toList(), currentLambda,
+                                           frame.pos);
                         case NEW:
-                            p.type = TargetType.CONSTRUCTOR_REFERENCE;
-                            break;
+                            return TypeAnnotationPosition
+                                .constructorRef(location.toList(),
+                                                currentLambda,
+                                                frame.pos);
                         default:
-                            Assert.error("Unknown method reference mode " + mrframe.mode +
-                                    " for tree " + tree + " within frame " + frame);
+                            throw new AssertionError("Unknown method reference mode " + mrframe.mode +
+                                                     " for tree " + tree + " within frame " + frame);
                         }
-                        p.pos = frame.pos;
                     } else if (mrframe.typeargs != null &&
                             mrframe.typeargs.contains(tree)) {
-                        int arg = mrframe.typeargs.indexOf(tree);
-                        p.type_index = arg;
+                        final int type_index = mrframe.typeargs.indexOf(tree);
                         switch (mrframe.mode) {
                         case INVOKE:
-                            p.type = TargetType.METHOD_REFERENCE_TYPE_ARGUMENT;
-                            break;
+                            return TypeAnnotationPosition
+                                .methodRefTypeArg(location.toList(),
+                                                  currentLambda,
+                                                  type_index, frame.pos);
                         case NEW:
-                            p.type = TargetType.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT;
-                            break;
+                            return TypeAnnotationPosition
+                                .constructorRefTypeArg(location.toList(),
+                                                       currentLambda,
+                                                       type_index, frame.pos);
                         default:
-                            Assert.error("Unknown method reference mode " + mrframe.mode +
-                                    " for tree " + tree + " within frame " + frame);
+                            throw new AssertionError("Unknown method reference mode " + mrframe.mode +
+                                                   " for tree " + tree + " within frame " + frame);
                         }
-                        p.pos = frame.pos;
                     } else {
-                        Assert.error("Could not determine type argument position of tree " + tree +
-                                " within frame " + frame);
+                        throw new AssertionError("Could not determine type argument position of tree " + tree +
+                                               " within frame " + frame);
                     }
-                    return;
                 }
 
                 case ARRAY_TYPE: {
-                    ListBuffer<TypePathEntry> index = new ListBuffer<>();
-                    index = index.append(TypePathEntry.ARRAY);
+                    location = location.prepend(TypePathEntry.ARRAY);
                     List<JCTree> newPath = path.tail;
                     while (true) {
                         JCTree npHead = newPath.tail.head;
                         if (npHead.hasTag(JCTree.Tag.TYPEARRAY)) {
                             newPath = newPath.tail;
-                            index = index.append(TypePathEntry.ARRAY);
+                            location = location.prepend(TypePathEntry.ARRAY);
                         } else if (npHead.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
                             newPath = newPath.tail;
                         } else {
                             break;
                         }
                     }
-                    p.location = p.location.prependList(index.toList());
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index, location);
                 }
 
                 case TYPE_PARAMETER:
                     if (path.tail.tail.head.hasTag(JCTree.Tag.CLASSDEF)) {
-                        JCClassDecl clazz = (JCClassDecl)path.tail.tail.head;
-                        p.type = TargetType.CLASS_TYPE_PARAMETER_BOUND;
-                        p.parameter_index = clazz.typarams.indexOf(path.tail.head);
-                        p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
-                        if (((JCTypeParameter)frame).bounds.get(0).type.isInterface()) {
-                            // Account for an implicit Object as bound 0
-                            p.bound_index += 1;
-                        }
+                        final JCClassDecl clazz =
+                            (JCClassDecl)path.tail.tail.head;
+                        final int parameter_index =
+                            clazz.typarams.indexOf(path.tail.head);
+                        final int bound_index =
+                            ((JCTypeParameter)frame).bounds.get(0)
+                            .type.isInterface() ?
+                            ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:
+                            ((JCTypeParameter)frame).bounds.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .typeParameterBound(location.toList(),
+                                                currentLambda,
+                                                parameter_index, bound_index,
+                                                frame.pos);
                     } else if (path.tail.tail.head.hasTag(JCTree.Tag.METHODDEF)) {
-                        JCMethodDecl method = (JCMethodDecl)path.tail.tail.head;
-                        p.type = TargetType.METHOD_TYPE_PARAMETER_BOUND;
-                        p.parameter_index = method.typarams.indexOf(path.tail.head);
-                        p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
-                        if (((JCTypeParameter)frame).bounds.get(0).type.isInterface()) {
-                            // Account for an implicit Object as bound 0
-                            p.bound_index += 1;
-                        }
+                        final JCMethodDecl method =
+                            (JCMethodDecl)path.tail.tail.head;
+                        final int parameter_index =
+                            method.typarams.indexOf(path.tail.head);
+                        final int bound_index =
+                            ((JCTypeParameter)frame).bounds.get(0)
+                            .type.isInterface() ?
+                            ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:
+                            ((JCTypeParameter)frame).bounds.indexOf(tree);
+                        return TypeAnnotationPosition
+                            .methodTypeParameterBound(location.toList(),
+                                                      currentLambda,
+                                                      parameter_index,
+                                                      bound_index,
+                                                      frame.pos);
                     } else {
-                        Assert.error("Could not determine position of tree " + tree +
-                                " within frame " + frame);
+                        throw new AssertionError("Could not determine position of tree " + tree +
+                                                 " within frame " + frame);
                     }
-                    p.pos = frame.pos;
-                    return;
 
                 case VARIABLE:
                     VarSymbol v = ((JCVariableDecl)frame).sym;
-                    p.pos = frame.pos;
-                    switch (v.getKind()) {
-                        case LOCAL_VARIABLE:
-                            p.type = TargetType.LOCAL_VARIABLE;
-                            break;
-                        case FIELD:
-                            p.type = TargetType.FIELD;
-                            break;
-                        case PARAMETER:
-                            if (v.getQualifiedName().equals(names._this)) {
-                                // TODO: Intro a separate ElementKind?
-                                p.type = TargetType.METHOD_RECEIVER;
-                            } else {
-                                p.type = TargetType.METHOD_FORMAL_PARAMETER;
-                                p.parameter_index = methodParamIndex(path, frame);
-                            }
-                            break;
-                        case EXCEPTION_PARAMETER:
-                            p.type = TargetType.EXCEPTION_PARAMETER;
-                            break;
-                        case RESOURCE_VARIABLE:
-                            p.type = TargetType.RESOURCE_VARIABLE;
-                            break;
-                        default:
-                            Assert.error("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
-                    }
                     if (v.getKind() != ElementKind.FIELD) {
                         v.owner.appendUniqueTypeAttributes(v.getRawTypeAttributes());
                     }
-                    return;
+                    switch (v.getKind()) {
+                        case LOCAL_VARIABLE:
+                            return TypeAnnotationPosition
+                                .localVariable(location.toList(), currentLambda,
+                                               frame.pos);
+                        case FIELD:
+                            return TypeAnnotationPosition.field(location.toList(),
+                                                                currentLambda,
+                                                                frame.pos);
+                        case PARAMETER:
+                            if (v.getQualifiedName().equals(names._this)) {
+                                return TypeAnnotationPosition
+                                    .methodReceiver(location.toList(),
+                                                    currentLambda,
+                                                    frame.pos);
+                            } else {
+                                final int parameter_index =
+                                    methodParamIndex(path, frame);
+                                return TypeAnnotationPosition
+                                    .methodParameter(location.toList(),
+                                                     currentLambda,
+                                                     parameter_index,
+                                                     frame.pos);
+                            }
+                        case EXCEPTION_PARAMETER:
+                            return TypeAnnotationPosition
+                                .exceptionParameter(location.toList(),
+                                                    currentLambda,
+                                                    frame.pos);
+                        case RESOURCE_VARIABLE:
+                            return TypeAnnotationPosition
+                                .resourceVariable(location.toList(),
+                                                  currentLambda,
+                                                  frame.pos);
+                        default:
+                            throw new AssertionError("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
+                    }
 
                 case ANNOTATED_TYPE: {
                     if (frame == tree) {
@@ -921,83 +970,89 @@
                             // class/method as enclosing elements.
                             // There is actually nothing to do for them.
                         } else {
-                            locateNestedTypes(utype, p);
+                            location = locateNestedTypes(utype, location);
                         }
                     }
                     List<JCTree> newPath = path.tail;
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index, location);
                 }
 
                 case UNION_TYPE: {
                     List<JCTree> newPath = path.tail;
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index, location);
                 }
 
                 case INTERSECTION_TYPE: {
                     JCTypeIntersection isect = (JCTypeIntersection)frame;
-                    p.type_index = isect.bounds.indexOf(tree);
-                    List<JCTree> newPath = path.tail;
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    final List<JCTree> newPath = path.tail;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        isect.bounds.indexOf(tree), location);
                 }
 
                 case METHOD_INVOCATION: {
                     JCMethodInvocation invocation = (JCMethodInvocation)frame;
                     if (!invocation.typeargs.contains(tree)) {
-                        Assert.error("{" + tree + "} is not an argument in the invocation: " + invocation);
+                        throw new AssertionError("{" + tree + "} is not an argument in the invocation: " + invocation);
                     }
                     MethodSymbol exsym = (MethodSymbol) TreeInfo.symbol(invocation.getMethodSelect());
+                    final int type_index = invocation.typeargs.indexOf(tree);
                     if (exsym == null) {
-                        Assert.error("could not determine symbol for {" + invocation + "}");
+                        throw new AssertionError("could not determine symbol for {" + invocation + "}");
                     } else if (exsym.isConstructor()) {
-                        p.type = TargetType.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT;
+                        return TypeAnnotationPosition
+                            .constructorInvocationTypeArg(location.toList(),
+                                                          currentLambda,
+                                                          type_index,
+                                                          invocation.pos);
                     } else {
-                        p.type = TargetType.METHOD_INVOCATION_TYPE_ARGUMENT;
+                        return TypeAnnotationPosition
+                            .methodInvocationTypeArg(location.toList(),
+                                                     currentLambda,
+                                                     type_index,
+                                                     invocation.pos);
                     }
-                    p.pos = invocation.pos;
-                    p.type_index = invocation.typeargs.indexOf(tree);
-                    return;
                 }
 
                 case EXTENDS_WILDCARD:
                 case SUPER_WILDCARD: {
                     // Annotations in wildcard bounds
-                    p.location = p.location.prepend(TypePathEntry.WILDCARD);
-                    List<JCTree> newPath = path.tail;
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    final List<JCTree> newPath = path.tail;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index,
+                                        location.prepend(TypePathEntry.WILDCARD));
                 }
 
                 case MEMBER_SELECT: {
-                    List<JCTree> newPath = path.tail;
-                    resolveFrame(newPath.head, newPath.tail.head, newPath, p);
-                    return;
+                    final List<JCTree> newPath = path.tail;
+                    return resolveFrame(newPath.head, newPath.tail.head,
+                                        newPath, currentLambda,
+                                        outer_type_index, location);
                 }
 
                 default:
-                    Assert.error("Unresolved frame: " + frame + " of kind: " + frame.getKind() +
-                            "\n    Looking for tree: " + tree);
-                    return;
+                    throw new AssertionError("Unresolved frame: " + frame +
+                                             " of kind: " + frame.getKind() +
+                                             "\n    Looking for tree: " + tree);
             }
         }
 
-        private void locateNestedTypes(Type type, TypeAnnotationPosition p) {
-            // The number of "steps" to get from the full type to the
-            // left-most outer type.
-            ListBuffer<TypePathEntry> depth = new ListBuffer<>();
-
+        private ListBuffer<TypePathEntry>
+            locateNestedTypes(Type type,
+                              ListBuffer<TypePathEntry> depth) {
             Type encl = type.getEnclosingType();
             while (encl != null &&
                     encl.getKind() != TypeKind.NONE &&
                     encl.getKind() != TypeKind.ERROR) {
-                depth = depth.append(TypePathEntry.INNER_TYPE);
+                depth = depth.prepend(TypePathEntry.INNER_TYPE);
                 encl = encl.getEnclosingType();
             }
-            if (depth.nonEmpty()) {
-                p.location = p.location.prependList(depth.toList());
-            }
+            return depth;
         }
 
         private int methodParamIndex(List<JCTree> path, JCTree param) {
@@ -1048,18 +1103,18 @@
             }
             if (sigOnly) {
                 if (!tree.mods.annotations.isEmpty()) {
-                    // Nothing to do for separateAnnotationsKinds if
-                    // there are no annotations of either kind.
-                    TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                    pos.type = TargetType.METHOD_RETURN;
                     if (tree.sym.isConstructor()) {
-                        pos.pos = tree.pos;
-                        // Use null to mark that the annotations go with the symbol.
+                        final TypeAnnotationPosition pos =
+                            TypeAnnotationPosition.methodReturn(tree.pos);
+                        // Use null to mark that the annotations go
+                        // with the symbol.
                         separateAnnotationsKinds(tree, null, tree.sym, pos);
                     } else {
-                        pos.pos = tree.restype.pos;
-                        separateAnnotationsKinds(tree.restype, tree.sym.type.getReturnType(),
-                                tree.sym, pos);
+                        final TypeAnnotationPosition pos =
+                            TypeAnnotationPosition.methodReturn(tree.restype.pos);
+                        separateAnnotationsKinds(tree.restype,
+                                                 tree.sym.type.getReturnType(),
+                                                 tree.sym, pos);
                     }
                 }
                 if (tree.recvparam != null && tree.recvparam.sym != null &&
@@ -1067,22 +1122,22 @@
                     // Nothing to do for separateAnnotationsKinds if
                     // there are no annotations of either kind.
                     // TODO: make sure there are no declaration annotations.
-                    TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                    pos.type = TargetType.METHOD_RECEIVER;
-                    pos.pos = tree.recvparam.vartype.pos;
-                    separateAnnotationsKinds(tree.recvparam.vartype, tree.recvparam.sym.type,
-                            tree.recvparam.sym, pos);
+                    final TypeAnnotationPosition pos =
+                        TypeAnnotationPosition.methodReceiver(tree.recvparam.vartype.pos);
+                    separateAnnotationsKinds(tree.recvparam.vartype,
+                                             tree.recvparam.sym.type,
+                                             tree.recvparam.sym, pos);
                 }
                 int i = 0;
                 for (JCVariableDecl param : tree.params) {
                     if (!param.mods.annotations.isEmpty()) {
                         // Nothing to do for separateAnnotationsKinds if
                         // there are no annotations of either kind.
-                        TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                        pos.type = TargetType.METHOD_FORMAL_PARAMETER;
-                        pos.parameter_index = i;
-                        pos.pos = param.vartype.pos;
-                        separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
+                        final TypeAnnotationPosition pos =
+                            TypeAnnotationPosition.methodParameter(i, param.vartype.pos);
+                        separateAnnotationsKinds(param.vartype,
+                                                 param.sym.type,
+                                                 param.sym, pos);
                     }
                     ++i;
                 }
@@ -1119,11 +1174,9 @@
                     if (!param.mods.annotations.isEmpty()) {
                         // Nothing to do for separateAnnotationsKinds if
                         // there are no annotations of either kind.
-                        TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                        pos.type = TargetType.METHOD_FORMAL_PARAMETER;
-                        pos.parameter_index = i;
-                        pos.pos = param.vartype.pos;
-                        pos.onLambda = tree;
+                        final TypeAnnotationPosition pos =
+                            TypeAnnotationPosition.methodParameter(tree, i,
+                                                                   param.vartype.pos);
                         separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
                     }
                     ++i;
@@ -1153,28 +1206,24 @@
                 // Parameters are handled in visitMethodDef or visitLambda.
             } else if (tree.sym.getKind() == ElementKind.FIELD) {
                 if (sigOnly) {
-                    TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                    pos.type = TargetType.FIELD;
-                    pos.pos = tree.pos;
+                    TypeAnnotationPosition pos =
+                        TypeAnnotationPosition.field(tree.pos);
                     separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
                 }
             } else if (tree.sym.getKind() == ElementKind.LOCAL_VARIABLE) {
-                TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                pos.type = TargetType.LOCAL_VARIABLE;
-                pos.pos = tree.pos;
-                pos.onLambda = currentLambda;
+                final TypeAnnotationPosition pos =
+                    TypeAnnotationPosition.localVariable(currentLambda,
+                                                         tree.pos);
                 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
             } else if (tree.sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {
-                TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                pos.type = TargetType.EXCEPTION_PARAMETER;
-                pos.pos = tree.pos;
-                pos.onLambda = currentLambda;
+                final TypeAnnotationPosition pos =
+                    TypeAnnotationPosition.exceptionParameter(currentLambda,
+                                                              tree.pos);
                 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
             } else if (tree.sym.getKind() == ElementKind.RESOURCE_VARIABLE) {
-                TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                pos.type = TargetType.RESOURCE_VARIABLE;
-                pos.pos = tree.pos;
-                pos.onLambda = currentLambda;
+                final TypeAnnotationPosition pos =
+                    TypeAnnotationPosition.resourceVariable(currentLambda,
+                                                            tree.pos);
                 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
             } else if (tree.sym.getKind() == ElementKind.ENUM_CONSTANT) {
                 // No type annotations can occur here.
@@ -1218,7 +1267,8 @@
 
         private void copyNewClassAnnotationsToOwner(JCNewClass tree) {
             Symbol sym = tree.def.sym;
-            TypeAnnotationPosition pos = new TypeAnnotationPosition();
+            final TypeAnnotationPosition pos =
+                TypeAnnotationPosition.newObj(tree.pos);
             ListBuffer<Attribute.TypeCompound> newattrs = new ListBuffer<>();
 
             for (Attribute.TypeCompound old : sym.getRawTypeAttributes()) {
@@ -1226,8 +1276,6 @@
                                                            pos));
             }
 
-            pos.type = TargetType.NEW;
-            pos.pos = tree.pos;
             sym.owner.appendUniqueTypeAttributes(newattrs.toList());
         }
 
@@ -1236,16 +1284,16 @@
             if (tree.def != null &&
                     !tree.def.mods.annotations.isEmpty()) {
                 JCClassDecl classdecl = tree.def;
-                TypeAnnotationPosition pos = new TypeAnnotationPosition();
-                pos.type = TargetType.CLASS_EXTENDS;
-                pos.pos = tree.pos;
+                TypeAnnotationPosition pos;
+
                 if (classdecl.extending == tree.clazz) {
-                    pos.type_index = -1;
+                    pos = TypeAnnotationPosition.classExtends(tree.pos);
                 } else if (classdecl.implementing.contains(tree.clazz)) {
-                    pos.type_index = classdecl.implementing.indexOf(tree.clazz);
+                    final int index = classdecl.implementing.indexOf(tree.clazz);
+                    pos = TypeAnnotationPosition.classExtends(index, tree.pos);
                 } else {
                     // In contrast to CLASS elsewhere, typarams cannot occur here.
-                    Assert.error("Could not determine position of tree " + tree);
+                    throw new AssertionError("Could not determine position of tree " + tree);
                 }
                 Type before = classdecl.sym.type;
                 separateAnnotationsKinds(classdecl, tree.clazz.type, classdecl.sym, pos);
@@ -1273,14 +1321,16 @@
 
             // handle annotations associated with dimensions
             for (int i = 0; i < dimAnnosCount; ++i) {
-                TypeAnnotationPosition p = new TypeAnnotationPosition();
-                p.pos = tree.pos;
-                p.onLambda = currentLambda;
-                p.type = TargetType.NEW;
+                ListBuffer<TypePathEntry> location =
+                    new ListBuffer<TypePathEntry>();
                 if (i != 0) {
                     depth = depth.append(TypePathEntry.ARRAY);
-                    p.location = p.location.appendList(depth.toList());
+                    location = location.appendList(depth.toList());
                 }
+                final TypeAnnotationPosition p =
+                    TypeAnnotationPosition.newObj(location.toList(),
+                                                  currentLambda,
+                                                  tree.pos);
 
                 setTypeAnnotationPos(tree.dimAnnotations.get(i), p);
             }
@@ -1293,12 +1343,14 @@
             while (elemType != null) {
                 if (elemType.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
                     JCAnnotatedType at = (JCAnnotatedType)elemType;
-                    TypeAnnotationPosition p = new TypeAnnotationPosition();
-                    p.type = TargetType.NEW;
-                    p.pos = tree.pos;
-                    p.onLambda = currentLambda;
-                    locateNestedTypes(elemType.type, p);
-                    p.location = p.location.prependList(depth.toList());
+                    final ListBuffer<TypePathEntry> locationbuf =
+                        locateNestedTypes(elemType.type,
+                                          new ListBuffer<TypePathEntry>());
+                    final List<TypePathEntry> location =
+                        locationbuf.toList().prependList(depth.toList());
+                    final TypeAnnotationPosition p =
+                        TypeAnnotationPosition.newObj(location, currentLambda,
+                                                      tree.pos);
                     setTypeAnnotationPos(at.annotations, p);
                     elemType = at.underlyingType;
                 } else if (elemType.hasTag(JCTree.Tag.TYPEARRAY)) {
@@ -1320,9 +1372,9 @@
                 System.err.println("    tree: " + tree + " kind: " + tree.getKind());
                 System.err.println("    frame: " + frame + " kind: " + frame.getKind());
                 */
-                TypeAnnotationPosition p = new TypeAnnotationPosition();
-                p.onLambda = currentLambda;
-                resolveFrame(tree, frame, frames.toList(), p);
+                final TypeAnnotationPosition p =
+                    resolveFrame(tree, frame, frames.toList(), currentLambda, 0,
+                                 new ListBuffer<TypePathEntry>());
                 setTypeAnnotationPos(annotations, p);
             }
         }
--- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Mon Feb 03 17:19:15 2014 -0500
@@ -299,7 +299,13 @@
         if (typeAnnotation) {
             if (a.attribute == null || !(a.attribute instanceof Attribute.TypeCompound)) {
                 // Create a new TypeCompound
-                Attribute.TypeCompound tc = new Attribute.TypeCompound(a.type, buf.toList(), new TypeAnnotationPosition());
+
+                Attribute.TypeCompound tc =
+                    new Attribute.TypeCompound(a.type, buf.toList(),
+                // TODO: Eventually, we will get rid of this use of
+                // unknown, because we'll get a position from
+                // MemberEnter (task 8027262).
+                                               TypeAnnotationPosition.unknown);
                 a.attribute = tc;
                 return tc;
             } else {
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Mon Feb 03 17:19:15 2014 -0500
@@ -1469,26 +1469,46 @@
         if (!TargetType.isValidTargetTypeValue(tag))
             throw this.badClassFile("bad.type.annotation.value", String.format("0x%02X", tag));
 
-        TypeAnnotationPosition position = new TypeAnnotationPosition();
         TargetType type = TargetType.fromTargetTypeValue(tag);
 
-        position.type = type;
-
         switch (type) {
         // instanceof
-        case INSTANCEOF:
+        case INSTANCEOF: {
+            final int offset = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.instanceOf(readTypePath());
+            position.offset = offset;
+            return position;
+        }
         // new expression
-        case NEW:
+        case NEW: {
+            final int offset = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.newObj(readTypePath());
+            position.offset = offset;
+            return position;
+        }
         // constructor/method reference receiver
-        case CONSTRUCTOR_REFERENCE:
-        case METHOD_REFERENCE:
-            position.offset = nextChar();
-            break;
+        case CONSTRUCTOR_REFERENCE: {
+            final int offset = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.constructorRef(readTypePath());
+            position.offset = offset;
+            return position;
+        }
+        case METHOD_REFERENCE: {
+            final int offset = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.methodRef(readTypePath());
+            position.offset = offset;
+            return position;
+        }
         // local variable
-        case LOCAL_VARIABLE:
-        // resource variable
-        case RESOURCE_VARIABLE:
-            int table_length = nextChar();
+        case LOCAL_VARIABLE: {
+            final int table_length = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.localVariable(readTypePath());
+
             position.lvarOffset = new int[table_length];
             position.lvarLength = new int[table_length];
             position.lvarIndex = new int[table_length];
@@ -1498,67 +1518,142 @@
                 position.lvarLength[i] = nextChar();
                 position.lvarIndex[i] = nextChar();
             }
-            break;
+            return position;
+        }
+        // resource variable
+        case RESOURCE_VARIABLE: {
+            final int table_length = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.resourceVariable(readTypePath());
+
+            position.lvarOffset = new int[table_length];
+            position.lvarLength = new int[table_length];
+            position.lvarIndex = new int[table_length];
+
+            for (int i = 0; i < table_length; ++i) {
+                position.lvarOffset[i] = nextChar();
+                position.lvarLength[i] = nextChar();
+                position.lvarIndex[i] = nextChar();
+            }
+            return position;
+        }
         // exception parameter
-        case EXCEPTION_PARAMETER:
-            position.exception_index = nextChar();
-            break;
+        case EXCEPTION_PARAMETER: {
+            final int exception_index = nextChar();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.exceptionParameter(readTypePath());
+            position.exception_index = exception_index;
+            return position;
+        }
         // method receiver
         case METHOD_RECEIVER:
-            // Do nothing
-            break;
+            return TypeAnnotationPosition.methodReceiver(readTypePath());
         // type parameter
-        case CLASS_TYPE_PARAMETER:
-        case METHOD_TYPE_PARAMETER:
-            position.parameter_index = nextByte();
-            break;
+        case CLASS_TYPE_PARAMETER: {
+            final int parameter_index = nextByte();
+            return TypeAnnotationPosition
+                .typeParameter(readTypePath(), parameter_index);
+        }
+        case METHOD_TYPE_PARAMETER: {
+            final int parameter_index = nextByte();
+            return TypeAnnotationPosition
+                .methodTypeParameter(readTypePath(), parameter_index);
+        }
         // type parameter bound
-        case CLASS_TYPE_PARAMETER_BOUND:
-        case METHOD_TYPE_PARAMETER_BOUND:
-            position.parameter_index = nextByte();
-            position.bound_index = nextByte();
-            break;
+        case CLASS_TYPE_PARAMETER_BOUND: {
+            final int parameter_index = nextByte();
+            final int bound_index = nextByte();
+            return TypeAnnotationPosition
+                .typeParameterBound(readTypePath(), parameter_index,
+                                    bound_index);
+        }
+        case METHOD_TYPE_PARAMETER_BOUND: {
+            final int parameter_index = nextByte();
+            final int bound_index = nextByte();
+            return TypeAnnotationPosition
+                .methodTypeParameterBound(readTypePath(), parameter_index,
+                                          bound_index);
+        }
         // class extends or implements clause
-        case CLASS_EXTENDS:
-            position.type_index = nextChar();
-            break;
+        case CLASS_EXTENDS: {
+            final int type_index = nextChar();
+            return TypeAnnotationPosition.classExtends(readTypePath(),
+                                                       type_index);
+        }
         // throws
-        case THROWS:
-            position.type_index = nextChar();
-            break;
+        case THROWS: {
+            final int type_index = nextChar();
+            return TypeAnnotationPosition.methodThrows(readTypePath(),
+                                                       type_index);
+        }
         // method parameter
-        case METHOD_FORMAL_PARAMETER:
-            position.parameter_index = nextByte();
-            break;
+        case METHOD_FORMAL_PARAMETER: {
+            final int parameter_index = nextByte();
+            return TypeAnnotationPosition.methodParameter(readTypePath(),
+                                                          parameter_index);
+        }
         // type cast
-        case CAST:
+        case CAST: {
+            final int offset = nextChar();
+            final int type_index = nextByte();
+            final TypeAnnotationPosition position =
+                TypeAnnotationPosition.typeCast(readTypePath(), type_index);
+            position.offset = offset;
+            return position;
+        }
         // method/constructor/reference type argument
-        case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
-        case METHOD_INVOCATION_TYPE_ARGUMENT:
-        case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
-        case METHOD_REFERENCE_TYPE_ARGUMENT:
-            position.offset = nextChar();
-            position.type_index = nextByte();
-            break;
+        case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: {
+            final int offset = nextChar();
+            final int type_index = nextByte();
+            final TypeAnnotationPosition position = TypeAnnotationPosition
+                .constructorInvocationTypeArg(readTypePath(), type_index);
+            position.offset = offset;
+            return position;
+        }
+        case METHOD_INVOCATION_TYPE_ARGUMENT: {
+            final int offset = nextChar();
+            final int type_index = nextByte();
+            final TypeAnnotationPosition position = TypeAnnotationPosition
+                .methodInvocationTypeArg(readTypePath(), type_index);
+            position.offset = offset;
+            return position;
+        }
+        case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: {
+            final int offset = nextChar();
+            final int type_index = nextByte();
+            final TypeAnnotationPosition position = TypeAnnotationPosition
+                .constructorRefTypeArg(readTypePath(), type_index);
+            position.offset = offset;
+            return position;
+        }
+        case METHOD_REFERENCE_TYPE_ARGUMENT: {
+            final int offset = nextChar();
+            final int type_index = nextByte();
+            final TypeAnnotationPosition position = TypeAnnotationPosition
+                .methodRefTypeArg(readTypePath(), type_index);
+            position.offset = offset;
+            return position;
+        }
         // We don't need to worry about these
         case METHOD_RETURN:
+            return TypeAnnotationPosition.methodReturn(readTypePath());
         case FIELD:
-            break;
+            return TypeAnnotationPosition.field(readTypePath());
         case UNKNOWN:
             throw new AssertionError("jvm.ClassReader: UNKNOWN target type should never occur!");
         default:
-            throw new AssertionError("jvm.ClassReader: Unknown target type for position: " + position);
+            throw new AssertionError("jvm.ClassReader: Unknown target type for position: " + type);
         }
+    }
 
-        { // See whether there is location info and read it
-            int len = nextByte();
-            ListBuffer<Integer> loc = new ListBuffer<>();
-            for (int i = 0; i < len * TypeAnnotationPosition.TypePathEntry.bytesPerEntry; ++i)
-                loc = loc.append(nextByte());
-            position.location = TypeAnnotationPosition.getTypePathFromBinary(loc.toList());
-        }
+    List<TypeAnnotationPosition.TypePathEntry> readTypePath() {
+        int len = nextByte();
+        ListBuffer<Integer> loc = new ListBuffer<>();
+        for (int i = 0; i < len * TypeAnnotationPosition.TypePathEntry.bytesPerEntry; ++i)
+            loc = loc.append(nextByte());
 
-        return position;
+        return TypeAnnotationPosition.getTypePathFromBinary(loc.toList());
+
     }
 
     Attribute readAttributeValue() {
--- a/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Sun Feb 02 12:12:01 2014 +0100
+++ b/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Mon Feb 03 17:19:15 2014 -0500
@@ -2299,6 +2299,9 @@
 
         // Attribute.Compound if tag is ANNOTATION
         // Attribute.TypeCompound if tag is TYPE_ANNOTATION
+        //
+        // NOTE: This field is slated for removal in the future.  Do
+        // not use it for anything new.
         public Attribute.Compound attribute;
 
         protected JCAnnotation(Tag tag, JCTree annotationType, List<JCExpression> args) {