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

-:3aa269645199
+:96d4226bdd60
 import com.sun.tools.javac.jvm.ClassReader;
 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.comp.Check;
+import static com.sun.tools.javac.code.Scope.*;
 import static com.sun.tools.javac.code.Type.*;
 import static com.sun.tools.javac.code.TypeTags.*;
 import static com.sun.tools.javac.code.Symbol.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.BoundKind.*;
 public class Types {
 protected static final Context.Key<Types> typesKey =
 new Context.Key<Types>();
 final Symtab syms;
-final Scope.ScopeCounter scopeCounter;
 final JavacMessages messages;
 final Names names;
 final boolean allowBoxing;
 final ClassReader reader;
 final Source source;
 }
 protected Types(Context context) {
 context.put(typesKey, this);
 syms = Symtab.instance(context);
-scopeCounter = Scope.ScopeCounter.instance(context);
 names = Names.instance(context);
 allowBoxing = Source.instance(context).allowBoxing();
 reader = ClassReader.instance(context);
 source = Source.instance(context);
 chk = Check.instance(context);
 class Entry {
 final MethodSymbol cachedImpl;
 final Filter<Symbol> implFilter;
 final boolean checkResult;
-final Scope.ScopeCounter scopeCounter;
 public Entry(MethodSymbol cachedImpl,
 Filter<Symbol> scopeFilter,
-boolean checkResult,
+boolean checkResult) {
-Scope.ScopeCounter scopeCounter) {
 this.cachedImpl = cachedImpl;
 this.implFilter = scopeFilter;
 this.checkResult = checkResult;
-this.scopeCounter = scopeCounter;
+}
-}
+boolean matches(Filter<Symbol> scopeFilter, boolean checkResult) {
-boolean matches(Filter<Symbol> scopeFilter, boolean checkResult, Scope.ScopeCounter scopeCounter) {
 return this.implFilter == scopeFilter &&
-this.checkResult == checkResult &&
+this.checkResult == checkResult;
-this.scopeCounter.val() >= scopeCounter.val();
+}
 }
-}
+MethodSymbol get(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Filter<Symbol> implFilter) {
-MethodSymbol get(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Filter<Symbol> implFilter, Scope.ScopeCounter scopeCounter) {
 SoftReference<Map<TypeSymbol, Entry>> ref_cache = _map.get(ms);
 Map<TypeSymbol, Entry> cache = ref_cache != null ? ref_cache.get() : null;
 if (cache == null) {
 cache = new HashMap<TypeSymbol, Entry>();
 _map.put(ms, new SoftReference<Map<TypeSymbol, Entry>>(cache));
 }
 Entry e = cache.get(origin);
 if (e == null ||
-!e.matches(implFilter, checkResult, scopeCounter)) {
+!e.matches(implFilter, checkResult)) {
 MethodSymbol impl = implementationInternal(ms, origin, Types.this, checkResult, implFilter);
-cache.put(origin, new Entry(impl, implFilter, checkResult, scopeCounter));
+cache.put(origin, new Entry(impl, implFilter, checkResult));
 return impl;
 }
 else {
 return e.cachedImpl;
 }
 }
 }
 private ImplementationCache implCache = new ImplementationCache();
-public MethodSymbol implementation(MethodSymbol ms, TypeSymbol origin, Types types, boolean checkResult, Filter<Symbol> implFilter) {
+public MethodSymbol implementation(MethodSymbol ms, TypeSymbol origin, boolean checkResult, Filter<Symbol> implFilter) {
-return implCache.get(ms, origin, checkResult, implFilter, scopeCounter);
+return implCache.get(ms, origin, checkResult, implFilter);
 }
+// </editor-fold>
+// <editor-fold defaultstate="collapsed" desc="compute transitive closure of all members in given site">
+public Scope membersClosure(Type site) {
+return membersClosure.visit(site);
+}
+UnaryVisitor<Scope> membersClosure = new UnaryVisitor<Scope>() {
+public Scope visitType(Type t, Void s) {
+return null;
+}
+@Override
+public Scope visitClassType(ClassType t, Void s) {
+ClassSymbol csym = (ClassSymbol)t.tsym;
+if (csym.membersClosure == null) {
+Scope membersClosure = new Scope(csym);
+for (Type i : interfaces(t)) {
+enterAll(visit(i), membersClosure);
+}
+enterAll(visit(supertype(t)), membersClosure);
+enterAll(csym.members(), membersClosure);
+csym.membersClosure = membersClosure;
+}
+return csym.membersClosure;
+}
+@Override
+public Scope visitTypeVar(TypeVar t, Void s) {
+return visit(t.getUpperBound());
+}
+public void enterAll(Scope s, Scope to) {
+if (s == null) return;
+List<Symbol> syms = List.nil();
+for (Scope.Entry e = s.elems ; e != null ; e = e.sibling) {
+syms = syms.prepend(e.sym);
+}
+for (Symbol sym : syms) {
+to.enter(sym);
+}
+}
+};
 // </editor-fold>
 /**
 * Does t have the same arguments as s?  It is assumed that both
 * types are (possibly polymorphic) method types.  Monomorphic

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

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

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