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

-:1b469fd31e35
+:1e7ad879f15e
 * questions.
 */
 package com.sun.tools.javac.code;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Inherited;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import javax.lang.model.element.*;
 import javax.tools.JavaFileObject;
 import com.sun.tools.javac.comp.Annotate;
 import com.sun.tools.javac.comp.Attr;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.comp.Env;
 import com.sun.tools.javac.jvm.*;
-import com.sun.tools.javac.model.*;
-import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.Name;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTag.CLASS;
 *  <p><b>This is NOT part of any supported API.
 *  If you write code that depends on this, you do so at your own risk.
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 */
-public abstract class Symbol implements Element {
+public abstract class Symbol extends AnnoConstruct implements Element {
-// public Throwable debug = new Throwable();
 /** The kind of this symbol.
 *  @see Kinds
 */
 public int kind;
 /** The attributes of this symbol are contained in this
 * SymbolMetadata. The SymbolMetadata instance is NOT immutable.
 */
 protected SymbolMetadata annotations;
 /** An accessor method for the attributes of this symbol.
 *  Attributes of class symbols should be accessed through the accessor
 *  method to make sure that the class symbol is loaded.
 */
 @Override
 public List<Attribute.Compound> getAnnotationMirrors() {
 return getRawAttributes();
 }
-/**
-* @deprecated this method should never be used by javac internally.
-*/
-@Deprecated
-public <A extends java.lang.annotation.Annotation> A getAnnotation(Class<A> annoType) {
-return JavacAnnoConstructs.getAnnotation(this, annoType);
-}
-// This method is part of the javax.lang.model API, do not use this in javac code.
-public <A extends java.lang.annotation.Annotation> A[] getAnnotationsByType(Class<A> annoType) {
-return JavacAnnoConstructs.getAnnotationsByType(this, annoType);
-}
 // TODO: getEnclosedElements should return a javac List, fix in FilteredMemberList
 public java.util.List<Symbol> getEnclosedElements() {
 return List.nil();
 }
 }
 return res = res.reverse();
 }
+// Helper to getAnnotation[s]
+@Override
+public <A extends Annotation> Attribute.Compound getAttribute(Class<A> annoType) {
+String name = annoType.getName();
+// Declaration annotations on type variables are stored in type attributes
+// on the owner of the TypeVariableSymbol
+List<Attribute.TypeCompound> candidates = owner.getRawTypeAttributes();
+for (Attribute.TypeCompound anno : candidates)
+if (anno.position.type == TargetType.CLASS_TYPE_PARAMETER ||
+anno.position.type == TargetType.METHOD_TYPE_PARAMETER)
+if (name.contentEquals(anno.type.tsym.flatName()))
+return anno;
+return null;
+}
 @Override
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return v.visitTypeParameter(this, p);
 }
 }
 } else {
 return Type.noType;
 }
 }
+/**
+* Returns the next class to search for inherited annotations or {@code null}
+* if the next class can't be found.
+*/
+private ClassSymbol getSuperClassToSearchForAnnotations() {
+Type sup = getSuperclass();
+if (!sup.hasTag(CLASS) || sup.isErroneous())
+return null;
+return (ClassSymbol) sup.tsym;
+}
+@Override
+protected <A extends Annotation> A[] getInheritedAnnotations(Class<A> annoType) {
+ClassSymbol sup = getSuperClassToSearchForAnnotations();
+return sup == null ? super.getInheritedAnnotations(annoType)
+: sup.getAnnotationsByType(annoType);
+}
 public ElementKind getKind() {
 long flags = flags();
 if ((flags & ANNOTATION) != 0)
 return ElementKind.ANNOTATION_TYPE;
 else if ((flags & INTERFACE) != 0)
 return NestingKind.LOCAL;
 else
 return NestingKind.MEMBER;
 }
-/**
-* Since this method works in terms of the runtime representation
-* of annotations, it should never be used by javac internally.
-*/
 @Override
-public <A extends java.lang.annotation.Annotation> A getAnnotation(Class<A> annoType) {
+protected <A extends Annotation> Attribute.Compound getAttribute(final Class<A> annoType) {
-return JavacAnnoConstructs.getAnnotation(this, annoType);
-}
+Attribute.Compound attrib = super.getAttribute(annoType);
+boolean inherited = annoType.isAnnotationPresent(Inherited.class);
+if (attrib != null || !inherited)
+return attrib;
+// Search supertypes
+ClassSymbol superType = getSuperClassToSearchForAnnotations();
+return superType == null ? null
+: superType.getAttribute(annoType);
+}
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 return v.visitType(this, p);
 }

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

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

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