jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java

-:184c0d6698c3
+:5043e7056be8
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.type.TypeKind;
 import javax.tools.JavaFileObject;
-import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Attribute.TypeCompound;
-import com.sun.tools.javac.code.Flags;
-import com.sun.tools.javac.code.Kinds;
 import com.sun.tools.javac.code.Type.AnnotatedType;
 import com.sun.tools.javac.code.Type.ArrayType;
 import com.sun.tools.javac.code.Type.CapturedType;
 import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Type.ErrorType;
 import com.sun.tools.javac.code.Type.UndetVar;
 import com.sun.tools.javac.code.Type.Visitor;
 import com.sun.tools.javac.code.Type.WildcardType;
 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry;
 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntryKind;
-import com.sun.tools.javac.code.TypeTag;
 import com.sun.tools.javac.code.Symbol.VarSymbol;
 import com.sun.tools.javac.code.Symbol.MethodSymbol;
 import com.sun.tools.javac.comp.Annotate;
 import com.sun.tools.javac.comp.Annotate.Annotator;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.tree.JCTree.JCTypeApply;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.tree.TreeScanner;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.Assert;
+import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Names;
 * separate declaration from type annotations and insert the type
 * annotations to their types;
 * and determine the TypeAnnotationPositions for all type annotations.
 */
 public class TypeAnnotations {
-// Class cannot be instantiated.
+protected static final Context.Key<TypeAnnotations> typeAnnosKey =
-private TypeAnnotations() {}
+new Context.Key<TypeAnnotations>();
+public static TypeAnnotations instance(Context context) {
+TypeAnnotations instance = context.get(typeAnnosKey);
+if (instance == null)
+instance = new TypeAnnotations(context);
+return instance;
+}
+final Log log;
+final Names names;
+final Symtab syms;
+final Annotate annotate;
+protected TypeAnnotations(Context context) {
+context.put(typeAnnosKey, this);
+names = Names.instance(context);
+log = Log.instance(context);
+syms = Symtab.instance(context);
+annotate = Annotate.instance(context);
+}
 /**
 * Separate type annotations from declaration annotations and
 * determine the correct positions for type annotations.
 * This version only visits types in signatures and should be
 * called from MemberEnter.
 * The method takes the Annotate object as parameter and
 * adds an Annotator to the correct Annotate queue for
 * later processing.
 */
-public static void organizeTypeAnnotationsSignatures(final Symtab syms, final Names names,
+public void organizeTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {
-final Log log, final Env<AttrContext> env, final JCClassDecl tree, final Annotate annotate) {
 annotate.afterRepeated( new Annotator() {
 @Override
 public void enterAnnotation() {
 JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);
 try {
-new TypeAnnotationPositions(syms, names, log, true).scan(tree);
+new TypeAnnotationPositions(true).scan(tree);
 } finally {
 log.useSource(oldSource);
 }
 }
 } );
 /**
 * This version only visits types in bodies, that is, field initializers,
 * top-level blocks, and method bodies, and should be called from Attr.
 */
-public static void organizeTypeAnnotationsBodies(Symtab syms, Names names, Log log, JCClassDecl tree) {
+public void organizeTypeAnnotationsBodies(JCClassDecl tree) {
-new TypeAnnotationPositions(syms, names, log, false).scan(tree);
+new TypeAnnotationPositions(false).scan(tree);
 }
 public enum AnnotationType { DECLARATION, TYPE, BOTH };
 /**
 * Determine whether an annotation is a declaration annotation,
 * a type annotation, or both.
 */
-public static AnnotationType annotationType(Symtab syms, Names names,
+public AnnotationType annotationType(Attribute.Compound a, Symbol s) {
-Attribute.Compound a, Symbol s) {
 Attribute.Compound atTarget =
 a.type.tsym.attribute(syms.annotationTargetType.tsym);
 if (atTarget == null) {
 return inferTargetMetaInfo(a, s);
 }
 private static AnnotationType inferTargetMetaInfo(Attribute.Compound a, Symbol s) {
 return AnnotationType.DECLARATION;
 }
-private static class TypeAnnotationPositions extends TreeScanner {
+private class TypeAnnotationPositions extends TreeScanner {
-private final Symtab syms;
-private final Names names;
-private final Log log;
 private final boolean sigOnly;
-private TypeAnnotationPositions(Symtab syms, Names names, Log log, boolean sigOnly) {
+TypeAnnotationPositions(boolean sigOnly) {
-this.syms = syms;
-this.names = names;
-this.log = log;
 this.sigOnly = sigOnly;
 }
 /*
 * When traversing the AST we keep the "frames" of visited
 List<Attribute.Compound> annotations = sym.getRawAttributes();
 ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<Attribute.Compound>();
 ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<Attribute.TypeCompound>();
 for (Attribute.Compound a : annotations) {
-switch (annotationType(syms, names, a, sym)) {
+switch (annotationType(a, sym)) {
 case DECLARATION:
 declAnnos.append(a);
 break;
 case BOTH: {
 declAnnos.append(a);
 sym.appendUniqueTypeAttributes(typeAnnotations);
 return;
 }
 // type is non-null and annotations are added to that type
-type = typeWithAnnotations(typetree, type, typeAnnotations, log);
+type = typeWithAnnotations(typetree, type, typeAnnotations);
 if (sym.getKind() == ElementKind.METHOD) {
 sym.type.asMethodType().restype = type;
 } else if (sym.getKind() == ElementKind.PARAMETER) {
 sym.type = type;
 // need to set its position explicitly.
 // The method returns a copy of type that contains these annotations.
 //
 // As a side effect the method sets the type annotation position of "annotations".
 // Note that it is assumed that all annotations share the same position.
-private static Type typeWithAnnotations(final JCTree typetree, final Type type,
+private Type typeWithAnnotations(final JCTree typetree, final Type type,
-final List<Attribute.TypeCompound> annotations, Log log) {
+final List<Attribute.TypeCompound> annotations) {
 // System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s)%n",
 //         typetree, type, annotations);
 if (annotations.isEmpty()) {
 return type;
 }
 tomodify = (Type.ArrayType) tomodify.elemtype;
 }
 arTree = arrayTypeTree(arTree.elemtype);
 depth = depth.append(TypePathEntry.ARRAY);
 }
-Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations, log);
+Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations);
 tomodify.elemtype = arelemType;
 {
 // All annotations share the same position; modify the first one.
 Attribute.TypeCompound a = annotations.get(0);
 TypeAnnotationPosition p = a.position;
 return type;
 } else if (type.getKind() == TypeKind.UNION) {
 // There is a TypeKind, but no TypeTag.
 JCTypeUnion tutree = (JCTypeUnion) typetree;
 JCExpression fst = tutree.alternatives.get(0);
-Type res = typeWithAnnotations(fst, fst.type, annotations, log);
+Type res = typeWithAnnotations(fst, fst.type, annotations);
 fst.type = res;
 // TODO: do we want to set res as first element in uct.alternatives?
 // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;
 // Return the un-annotated union-type.
 return type;
 typetree.type = ret;
 return ret;
 }
 }
-private static JCArrayTypeTree arrayTypeTree(JCTree typetree) {
+private JCArrayTypeTree arrayTypeTree(JCTree typetree) {
 if (typetree.getKind() == JCTree.Kind.ARRAY_TYPE) {
 return (JCArrayTypeTree) typetree;
 } else if (typetree.getKind() == JCTree.Kind.ANNOTATED_TYPE) {
 return (JCArrayTypeTree) ((JCAnnotatedType)typetree).underlyingType;
 } else {
 * @param type The type to copy.
 * @param stopAt The type to stop at.
 * @param annotations The annotations to insert.
 * @return A copy of type that contains the annotations.
 */
-private static Type typeWithAnnotations(final Type type,
+private Type typeWithAnnotations(final Type type,
 final Type stopAt,
 final List<Attribute.TypeCompound> annotations) {
 Visitor<Type, List<TypeCompound>> visitor =
 new Type.Visitor<Type, List<Attribute.TypeCompound>>() {
 @Override
 };
 return type.accept(visitor, annotations);
 }
-private static Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) {
+private Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) {
 // It is safe to alias the position.
 return new Attribute.TypeCompound(a, p);
 }
 "\n    Looking for tree: " + tree);
 return;
 }
 }
-private static void locateNestedTypes(Type type, TypeAnnotationPosition p) {
+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<>();
 Type encl = type.getEnclosingType();
 if (depth.nonEmpty()) {
 p.location = p.location.prependList(depth.toList());
 }
 }
-private static int methodParamIndex(List<JCTree> path, JCTree param) {
+private int methodParamIndex(List<JCTree> path, JCTree param) {
 List<JCTree> curr = path;
 while (curr.head.getTag() != Tag.METHODDEF &&
 curr.head.getTag() != Tag.LAMBDA) {
 curr = curr.tail;
 }
 resolveFrame(tree, frame, frames.toList(), p);
 setTypeAnnotationPos(annotations, p);
 }
 }
-private static void setTypeAnnotationPos(List<JCAnnotation> annotations,
+private void setTypeAnnotationPos(List<JCAnnotation> annotations,
 TypeAnnotationPosition position) {
 for (JCAnnotation anno : annotations) {
 // attribute might be null during DeferredAttr;
 // we will be back later.
 if (anno.attribute != null) {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java

src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java