jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java

equal deleted inserted replaced

-:67811024e8b4
+:1297fbaf34fa
 /* This is the beginning of the second part of organizing
 * type annotations: determine the type annotation positions.
 */
-private void resolveFrame(JCTree tree, JCTree frame,
+// This method is considered deprecated, and will be removed
-List<JCTree> path, TypeAnnotationPosition p) {
+// 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());
 */
 // Note that p.offset is set in
 // com.sun.tools.javac.jvm.Gen.setTypeAnnotationPositions(int)
 switch (frame.getKind()) {
 case TYPE_CAST:
-JCTypeCast frameTC = (JCTypeCast) frame;
+return TypeAnnotationPosition.typeCast(location.toList(),
-p.type = TargetType.CAST;
+currentLambda,
-if (frameTC.clazz.hasTag(Tag.TYPEINTERSECTION)) {
+outer_type_index,
-// This case was already handled by INTERSECTION_TYPE
+frame.pos);
-} else {
-p.type_index = 0;
-}
-p.pos = frame.pos;
-return;
 case INSTANCE_OF:
-p.type = TargetType.INSTANCEOF;
+return TypeAnnotationPosition.instanceOf(location.toList(),
-p.pos = frame.pos;
+currentLambda,
-return;
+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;
+return TypeAnnotationPosition
-p.type_index = -1;
+.classExtends(location.toList(), currentLambda,
+frame.pos);
 } else if (frameClassDecl.implementing.contains(tree)) {
-p.type = TargetType.CLASS_EXTENDS;
+final int type_index =
-p.type_index = frameClassDecl.implementing.indexOf(tree);
+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 +
+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;
+final int type_index =
-p.type_index = frameNewClass.typeargs.indexOf(tree);
+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,
-p.pos = frame.pos;
+frame.pos);
-return;
+}
 case NEW_ARRAY:
-p.type = TargetType.NEW;
+return TypeAnnotationPosition
-p.pos = frame.pos;
+.newObj(location.toList(), currentLambda, frame.pos);
-return;
 case ANNOTATION_TYPE:
 case CLASS:
 case ENUM:
 case INTERFACE:
-p.pos = frame.pos;
 if (((JCClassDecl)frame).extending == tree) {
-p.type = TargetType.CLASS_EXTENDS;
+return TypeAnnotationPosition
-p.type_index = -1;
+.classExtends(location.toList(), currentLambda,
+frame.pos);
 } else if (((JCClassDecl)frame).implementing.contains(tree)) {
-p.type = TargetType.CLASS_EXTENDS;
+final int type_index =
-p.type_index = ((JCClassDecl)frame).implementing.indexOf(tree);
+((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;
+final int parameter_index =
-p.parameter_index = ((JCClassDecl)frame).typarams.indexOf(tree);
+((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 +
+throw new AssertionError("Could not determine position of tree " +
-" within frame " + frame);
+tree + " within frame " + frame);
 }
-return;
 case METHOD: {
-JCMethodDecl frameMethod = (JCMethodDecl) frame;
+final JCMethodDecl frameMethod = (JCMethodDecl) frame;
-p.pos = frame.pos;
 if (frameMethod.thrown.contains(tree)) {
-p.type = TargetType.THROWS;
+final int type_index = frameMethod.thrown.indexOf(tree);
-p.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;
+final int parameter_index =
-p.parameter_index = frameMethod.typarams.indexOf(tree);
+frameMethod.typarams.indexOf(tree);
+return TypeAnnotationPosition
+.methodTypeParameter(location.toList(),
+currentLambda,
+parameter_index, frame.pos);
 } else {
-Assert.error("Could not determine position of tree " + tree +
+throw new AssertionError("Could not determine position of tree " + tree +
 " within frame " + frame);
 }
-return;
 }
 case PARAMETERIZED_TYPE: {
 List<JCTree> newPath = path.tail;
 if (((JCTypeApply)frame).clazz == tree) {
 // generic: RAW; noop
 } 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 (newPath.tail != null &&
-// If we are within an anonymous class instantiation, use its type,
+newPath.tail.head.hasTag(Tag.NEWCLASS)) {
-// because it contains a correctly nested type.
+// 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 +
+throw new AssertionError("Could not determine type argument position of tree " + tree +
 " within frame " + frame);
 }
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+return resolveFrame(newPath.head, newPath.tail.head,
-return;
+newPath, currentLambda,
+outer_type_index, location);
 }
 case MEMBER_REFERENCE: {
 JCMemberReference mrframe = (JCMemberReference) frame;
 if (mrframe.expr == tree) {
 switch (mrframe.mode) {
 case INVOKE:
-p.type = TargetType.METHOD_REFERENCE;
+return TypeAnnotationPosition
-break;
+.methodRef(location.toList(), currentLambda,
+frame.pos);
 case NEW:
-p.type = TargetType.CONSTRUCTOR_REFERENCE;
+return TypeAnnotationPosition
-break;
+.constructorRef(location.toList(),
+currentLambda,
+frame.pos);
 default:
-Assert.error("Unknown method reference mode " + mrframe.mode +
+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);
+final int type_index = mrframe.typeargs.indexOf(tree);
-p.type_index = arg;
 switch (mrframe.mode) {
 case INVOKE:
-p.type = TargetType.METHOD_REFERENCE_TYPE_ARGUMENT;
+return TypeAnnotationPosition
-break;
+.methodRefTypeArg(location.toList(),
+currentLambda,
+type_index, frame.pos);
 case NEW:
-p.type = TargetType.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT;
+return TypeAnnotationPosition
-break;
+.constructorRefTypeArg(location.toList(),
+currentLambda,
+type_index, frame.pos);
 default:
-Assert.error("Unknown method reference mode " + mrframe.mode +
+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 +
+throw new AssertionError("Could not determine type argument position of tree " + tree +
 " within frame " + frame);
 }
-return;
 }
 case ARRAY_TYPE: {
-ListBuffer<TypePathEntry> index = new ListBuffer<>();
+location = location.prepend(TypePathEntry.ARRAY);
-index = index.append(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());
+return resolveFrame(newPath.head, newPath.tail.head,
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+newPath, currentLambda,
-return;
+outer_type_index, location);
 }
 case TYPE_PARAMETER:
 if (path.tail.tail.head.hasTag(JCTree.Tag.CLASSDEF)) {
-JCClassDecl clazz = (JCClassDecl)path.tail.tail.head;
+final JCClassDecl clazz =
-p.type = TargetType.CLASS_TYPE_PARAMETER_BOUND;
+(JCClassDecl)path.tail.tail.head;
-p.parameter_index = clazz.typarams.indexOf(path.tail.head);
+final int parameter_index =
-p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
+clazz.typarams.indexOf(path.tail.head);
-if (((JCTypeParameter)frame).bounds.get(0).type.isInterface()) {
+final int bound_index =
-// Account for an implicit Object as bound 0
+((JCTypeParameter)frame).bounds.get(0)
-p.bound_index += 1;
+.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;
+final JCMethodDecl method =
-p.type = TargetType.METHOD_TYPE_PARAMETER_BOUND;
+(JCMethodDecl)path.tail.tail.head;
-p.parameter_index = method.typarams.indexOf(path.tail.head);
+final int parameter_index =
-p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
+method.typarams.indexOf(path.tail.head);
-if (((JCTypeParameter)frame).bounds.get(0).type.isInterface()) {
+final int bound_index =
-// Account for an implicit Object as bound 0
+((JCTypeParameter)frame).bounds.get(0)
-p.bound_index += 1;
+.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 +
+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;
+if (v.getKind() != ElementKind.FIELD) {
+v.owner.appendUniqueTypeAttributes(v.getRawTypeAttributes());
+}
 switch (v.getKind()) {
 case LOCAL_VARIABLE:
-p.type = TargetType.LOCAL_VARIABLE;
+return TypeAnnotationPosition
-break;
+.localVariable(location.toList(), currentLambda,
+frame.pos);
 case FIELD:
-p.type = TargetType.FIELD;
+return TypeAnnotationPosition.field(location.toList(),
-break;
+currentLambda,
+frame.pos);
 case PARAMETER:
 if (v.getQualifiedName().equals(names._this)) {
-// TODO: Intro a separate ElementKind?
+return TypeAnnotationPosition
-p.type = TargetType.METHOD_RECEIVER;
+.methodReceiver(location.toList(),
+currentLambda,
+frame.pos);
 } else {
-p.type = TargetType.METHOD_FORMAL_PARAMETER;
+final int parameter_index =
-p.parameter_index = methodParamIndex(path, frame);
+methodParamIndex(path, frame);
+return TypeAnnotationPosition
+.methodParameter(location.toList(),
+currentLambda,
+parameter_index,
+frame.pos);
 }
-break;
 case EXCEPTION_PARAMETER:
-p.type = TargetType.EXCEPTION_PARAMETER;
+return TypeAnnotationPosition
-break;
+.exceptionParameter(location.toList(),
+currentLambda,
+frame.pos);
 case RESOURCE_VARIABLE:
-p.type = TargetType.RESOURCE_VARIABLE;
+return TypeAnnotationPosition
-break;
+.resourceVariable(location.toList(),
+currentLambda,
+frame.pos);
 default:
-Assert.error("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
+throw new AssertionError("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
 }
-if (v.getKind() != ElementKind.FIELD) {
-v.owner.appendUniqueTypeAttributes(v.getRawTypeAttributes());
-}
-return;
 case ANNOTATED_TYPE: {
 if (frame == tree) {
 // This is only true for the first annotated type we see.
 // For any other annotated types along the path, we do
 utype.getKind().equals(TypeKind.ARRAY)) {
 // Type parameters, wildcards, and arrays have the declaring
 // 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 resolveFrame(newPath.head, newPath.tail.head,
-return;
+newPath, currentLambda,
+outer_type_index, location);
 }
 case UNION_TYPE: {
 List<JCTree> newPath = path.tail;
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+return resolveFrame(newPath.head, newPath.tail.head,
-return;
+newPath, currentLambda,
+outer_type_index, location);
 }
 case INTERSECTION_TYPE: {
 JCTypeIntersection isect = (JCTypeIntersection)frame;
-p.type_index = isect.bounds.indexOf(tree);
+final List<JCTree> newPath = path.tail;
-List<JCTree> newPath = path.tail;
+return resolveFrame(newPath.head, newPath.tail.head,
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+newPath, currentLambda,
-return;
+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(),
-p.pos = invocation.pos;
+currentLambda,
-p.type_index = invocation.typeargs.indexOf(tree);
+type_index,
-return;
+invocation.pos);
+}
 }
 case EXTENDS_WILDCARD:
 case SUPER_WILDCARD: {
 // Annotations in wildcard bounds
-p.location = p.location.prepend(TypePathEntry.WILDCARD);
+final List<JCTree> newPath = path.tail;
-List<JCTree> newPath = path.tail;
+return resolveFrame(newPath.head, newPath.tail.head,
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+newPath, currentLambda,
-return;
+outer_type_index,
+location.prepend(TypePathEntry.WILDCARD));
 }
 case MEMBER_SELECT: {
-List<JCTree> newPath = path.tail;
+final List<JCTree> newPath = path.tail;
-resolveFrame(newPath.head, newPath.tail.head, newPath, p);
+return resolveFrame(newPath.head, newPath.tail.head,
-return;
+newPath, currentLambda,
+outer_type_index, location);
 }
 default:
-Assert.error("Unresolved frame: " + frame + " of kind: " + frame.getKind() +
+throw new AssertionError("Unresolved frame: " + frame +
-"\n    Looking for tree: " + tree);
+" of kind: " + frame.getKind() +
-return;
+"\n    Looking for tree: " + tree);
 }
 }
-private void locateNestedTypes(Type type, TypeAnnotationPosition p) {
+private ListBuffer<TypePathEntry>
-// The number of "steps" to get from the full type to the
+locateNestedTypes(Type type,
-// left-most outer type.
+ListBuffer<TypePathEntry> depth) {
-ListBuffer<TypePathEntry> depth = new ListBuffer<>();
 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()) {
+return depth;
-p.location = p.location.prependList(depth.toList());
-}
 }
 private int methodParamIndex(List<JCTree> path, JCTree param) {
 List<JCTree> curr = path;
 while (curr.head.getTag() != Tag.METHODDEF &&
 if (tree.sym == null) {
 Assert.error("Visiting tree node before memberEnter");
 }
 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;
+final TypeAnnotationPosition pos =
-// Use null to mark that the annotations go with the symbol.
+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;
+final TypeAnnotationPosition pos =
-separateAnnotationsKinds(tree.restype, tree.sym.type.getReturnType(),
+TypeAnnotationPosition.methodReturn(tree.restype.pos);
-tree.sym, pos);
+separateAnnotationsKinds(tree.restype,
+tree.sym.type.getReturnType(),
+tree.sym, pos);
 }
 }
 if (tree.recvparam != null && tree.recvparam.sym != null &&
 !tree.recvparam.mods.annotations.isEmpty()) {
 // 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();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.METHOD_RECEIVER;
+TypeAnnotationPosition.methodReceiver(tree.recvparam.vartype.pos);
-pos.pos = tree.recvparam.vartype.pos;
+separateAnnotationsKinds(tree.recvparam.vartype,
-separateAnnotationsKinds(tree.recvparam.vartype, tree.recvparam.sym.type,
+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();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.METHOD_FORMAL_PARAMETER;
+TypeAnnotationPosition.methodParameter(i, param.vartype.pos);
-pos.parameter_index = i;
+separateAnnotationsKinds(param.vartype,
-pos.pos = param.vartype.pos;
+param.sym.type,
-separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
+param.sym, pos);
 }
 ++i;
 }
 }
 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();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.METHOD_FORMAL_PARAMETER;
+TypeAnnotationPosition.methodParameter(tree, i,
-pos.parameter_index = i;
+param.vartype.pos);
-pos.pos = param.vartype.pos;
-pos.onLambda = tree;
 separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
 }
 ++i;
 }
 Assert.error("Visiting tree node before memberEnter");
 } else if (tree.sym.getKind() == ElementKind.PARAMETER) {
 // Parameters are handled in visitMethodDef or visitLambda.
 } else if (tree.sym.getKind() == ElementKind.FIELD) {
 if (sigOnly) {
-TypeAnnotationPosition pos = new TypeAnnotationPosition();
+TypeAnnotationPosition pos =
-pos.type = TargetType.FIELD;
+TypeAnnotationPosition.field(tree.pos);
-pos.pos = tree.pos;
 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
 }
 } else if (tree.sym.getKind() == ElementKind.LOCAL_VARIABLE) {
-TypeAnnotationPosition pos = new TypeAnnotationPosition();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.LOCAL_VARIABLE;
+TypeAnnotationPosition.localVariable(currentLambda,
-pos.pos = tree.pos;
+tree.pos);
-pos.onLambda = currentLambda;
 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
 } else if (tree.sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {
-TypeAnnotationPosition pos = new TypeAnnotationPosition();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.EXCEPTION_PARAMETER;
+TypeAnnotationPosition.exceptionParameter(currentLambda,
-pos.pos = tree.pos;
+tree.pos);
-pos.onLambda = currentLambda;
 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
 } else if (tree.sym.getKind() == ElementKind.RESOURCE_VARIABLE) {
-TypeAnnotationPosition pos = new TypeAnnotationPosition();
+final TypeAnnotationPosition pos =
-pos.type = TargetType.RESOURCE_VARIABLE;
+TypeAnnotationPosition.resourceVariable(currentLambda,
-pos.pos = tree.pos;
+tree.pos);
-pos.onLambda = currentLambda;
 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
 } else if (tree.sym.getKind() == ElementKind.ENUM_CONSTANT) {
 // No type annotations can occur here.
 } else {
 // There is nothing else in a variable declaration that needs separation.
 super.visitTypeParameter(tree);
 }
 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()) {
 newattrs.append(new Attribute.TypeCompound(old.type, old.values,
 pos));
 }
-pos.type = TargetType.NEW;
-pos.pos = tree.pos;
 sym.owner.appendUniqueTypeAttributes(newattrs.toList());
 }
 @Override
 public void visitNewClass(JCNewClass tree) {
 if (tree.def != null &&
 !tree.def.mods.annotations.isEmpty()) {
 JCClassDecl classdecl = tree.def;
-TypeAnnotationPosition pos = new TypeAnnotationPosition();
+TypeAnnotationPosition pos;
-pos.type = TargetType.CLASS_EXTENDS;
-pos.pos = tree.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);
 copyNewClassAnnotationsToOwner(tree);
 // classdecl.sym.type now contains an annotated type, which
 int dimAnnosCount = tree.dimAnnotations.size();
 ListBuffer<TypePathEntry> depth = new ListBuffer<>();
 // handle annotations associated with dimensions
 for (int i = 0; i < dimAnnosCount; ++i) {
-TypeAnnotationPosition p = new TypeAnnotationPosition();
+ListBuffer<TypePathEntry> location =
-p.pos = tree.pos;
+new ListBuffer<TypePathEntry>();
-p.onLambda = currentLambda;
-p.type = TargetType.NEW;
 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);
 }
 // handle "free" annotations
 JCExpression elemType = tree.elemtype;
 depth = depth.append(TypePathEntry.ARRAY);
 while (elemType != null) {
 if (elemType.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
 JCAnnotatedType at = (JCAnnotatedType)elemType;
-TypeAnnotationPosition p = new TypeAnnotationPosition();
+final ListBuffer<TypePathEntry> locationbuf =
-p.type = TargetType.NEW;
+locateNestedTypes(elemType.type,
-p.pos = tree.pos;
+new ListBuffer<TypePathEntry>());
-p.onLambda = currentLambda;
+final List<TypePathEntry> location =
-locateNestedTypes(elemType.type, p);
+locationbuf.toList().prependList(depth.toList());
-p.location = p.location.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)) {
 depth = depth.append(TypePathEntry.ARRAY);
 elemType = ((JCArrayTypeTree)elemType).elemtype;
 /*
 System.err.println("Finding pos for: " + annotations);
 System.err.println("    tree: " + tree + " kind: " + tree.getKind());
 System.err.println("    frame: " + frame + " kind: " + frame.getKind());
 */
-TypeAnnotationPosition p = new TypeAnnotationPosition();
+final TypeAnnotationPosition p =
-p.onLambda = currentLambda;
+resolveFrame(tree, frame, frames.toList(), currentLambda, 0,
-resolveFrame(tree, frame, frames.toList(), p);
+new ListBuffer<TypePathEntry>());
 setTypeAnnotationPos(annotations, p);
 }
 }
 private void setTypeAnnotationPos(List<JCAnnotation> annotations,

changeset 22702	1297fbaf34fa
parent 22699	3b17c61ad5a1
child 24396	3c36c6afcbca