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

equal deleted inserted replaced

-:4161b56e0d20
+:3873b4aaf4a8
 /** The number of elements in this scope.
 * This includes deleted elements, whose value is the sentinel.
 */
 int nelems = 0;
-/** A timestamp - useful to quickly check whether a scope has changed or not
-*/
-public ScopeCounter scopeCounter;
-static ScopeCounter dummyCounter = new ScopeCounter() {
-@Override
-public void inc() {
-//do nothing
-}
-};
 /** A list of scopes to be notified if items are to be removed from this scope.
 */
 List<Scope> listeners = List.nil();
-public static class ScopeCounter {
-protected static final Context.Key<ScopeCounter> scopeCounterKey =
-new Context.Key<ScopeCounter>();
-public static ScopeCounter instance(Context context) {
-ScopeCounter instance = context.get(scopeCounterKey);
-if (instance == null)
-instance = new ScopeCounter(context);
-return instance;
-}
-protected ScopeCounter(Context context) {
-context.put(scopeCounterKey, this);
-}
-private ScopeCounter() {};
-private long val = 0;
-public void inc() {
-val++;
-}
-public long val() {
-return val;
-}
-}
 /** Use as a "not-found" result for lookup.
 * Also used to mark deleted entries in the table.
 */
 private static final Entry sentinel = new Entry(null, null, null, null);
 */
 private static final int INITIAL_SIZE = 0x10;
 /** A value for the empty scope.
 */
-public static final Scope emptyScope = new Scope(null, null, new Entry[]{}, dummyCounter);
+public static final Scope emptyScope = new Scope(null, null, new Entry[]{});
 /** Construct a new scope, within scope next, with given owner, using
 *  given table. The table's length must be an exponent of 2.
 */
-private Scope(Scope next, Symbol owner, Entry[] table, ScopeCounter scopeCounter) {
+private Scope(Scope next, Symbol owner, Entry[] table) {
 this.next = next;
 Assert.check(emptyScope == null || owner != null);
 this.owner = owner;
 this.table = table;
 this.hashMask = table.length - 1;
-this.scopeCounter = scopeCounter;
 }
 /** Convenience constructor used for dup and dupUnshared. */
-private Scope(Scope next, Symbol owner, Entry[] table) {
+private Scope(Scope next, Symbol owner, Entry[] table, int nelems) {
-this(next, owner, table, next.scopeCounter);
+this(next, owner, table);
-this.nelems = next.nelems;
+this.nelems = nelems;
 }
 /** Construct a new scope, within scope next, with given owner,
 *  using a fresh table of length INITIAL_SIZE.
 */
 public Scope(Symbol owner) {
-this(owner, dummyCounter);
+this(null, owner, new Entry[INITIAL_SIZE]);
-}
-protected Scope(Symbol owner, ScopeCounter scopeCounter) {
-this(null, owner, new Entry[INITIAL_SIZE], scopeCounter);
 }
 /** Construct a fresh scope within this scope, with same owner,
 *  which shares its table with the outer scope. Used in connection with
 *  method leave if scope access is stack-like in order to avoid allocation
 *  which shares its table with the outer scope. Used in connection with
 *  method leave if scope access is stack-like in order to avoid allocation
 *  of fresh tables.
 */
 public Scope dup(Symbol newOwner) {
-Scope result = new Scope(this, newOwner, this.table);
+Scope result = new Scope(this, newOwner, this.table, this.nelems);
 shared++;
 // System.out.println("====> duping scope " + this.hashCode() + " owned by " + newOwner + " to " + result.hashCode());
 // new Error().printStackTrace(System.out);
 return result;
 }
 /** Construct a fresh scope within this scope, with same owner,
 *  with a new hash table, whose contents initially are those of
 *  the table of its outer scope.
 */
 public Scope dupUnshared() {
-return new Scope(this, this.owner, this.table.clone());
+return new Scope(this, this.owner, this.table.clone(), this.nelems);
 }
 /** Remove all entries of this scope from its table, if shared
 *  with next.
 */
 nelems++;
 }
 Entry e = makeEntry(sym, old, elems, s, origin);
 table[hash] = e;
 elems = e;
-scopeCounter.inc();
 }
 Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
 return new Entry(sym, shadowed, sibling, scope);
 }
 */
 public void remove(Symbol sym) {
 Assert.check(shared == 0);
 Entry e = lookup(sym.name);
 if (e.scope == null) return;
-scopeCounter.inc();
 // remove e from table and shadowed list;
 int i = getIndex(sym.name);
 Entry te = table[i];
 if (te == e)
 public static class DelegatedScope extends Scope {
 Scope delegatee;
 public static final Entry[] emptyTable = new Entry[0];
 public DelegatedScope(Scope outer) {
-super(outer, outer.owner, emptyTable, outer.scopeCounter);
+super(outer, outer.owner, emptyTable);
 delegatee = outer;
 }
 public Scope dup() {
 return new DelegatedScope(next);
 }
 public void remove(Symbol sym) {
 throw new AssertionError(sym);
 }
 public Entry lookup(Name name) {
 return delegatee.lookup(name);
-}
-}
-/** A class scope, for which a scope counter should be provided */
-public static class ClassScope extends Scope {
-ClassScope(Scope next, Symbol owner, Entry[] table, ScopeCounter scopeCounter) {
-super(next, owner, table, scopeCounter);
-}
-public ClassScope(Symbol owner, ScopeCounter scopeCounter) {
-super(owner, scopeCounter);
 }
 }
 /** An error scope, for which the owner should be an error symbol. */
 public static class ErrorScope extends Scope {
 ErrorScope(Scope next, Symbol errSymbol, Entry[] table) {
-super(next, /*owner=*/errSymbol, table, dummyCounter);
+super(next, /*owner=*/errSymbol, table);
 }
 public ErrorScope(Symbol errSymbol) {
 super(errSymbol);
 }
 public Scope dup() {

changeset 8242	3873b4aaf4a8
parent 8032	e1aa25ccdabb
child 8427	703181b01773