Add SubclassNode to prepare for optimized queries on ClassWorld.

tests/compiler/dart2js/class_set_test.dart

+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Test for iterators on for [SubclassNode].
+
+library world_test;
+
+import 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+import 'type_test_helper.dart';
+import 'package:compiler/src/elements/elements.dart'
+       show Element, ClassElement;
+import 'package:compiler/src/dart2jslib.dart';
+import 'package:compiler/src/universe/class_set.dart';
+import 'package:compiler/src/util/util.dart';
+
+void main() {
+  asyncTest(() => TypeEnvironment.create(r"""
+      ///        A
+      ///       / \
+      ///      B   C
+      ///     /   /|\
+      ///    D   E F G
+      ///
+      class A {}
+      class B extends A {}
+      class C extends A {}
+      class D extends B {}
+      class E extends C {}
+      class F extends C {}
+      class G extends C {}
+      """,
+        mainSource: r"""
+      main() {
+        new A();
+        new C();
+        new D();
+        new E();
+        new F();
+        new G();
+      }
+      """,
+      useMockCompiler: false).then((env) {
+    World world = env.compiler.world;
+
+    ClassElement A = env.getElement("A");
+    ClassElement B = env.getElement("B");
+    ClassElement C = env.getElement("C");
+    ClassElement D = env.getElement("D");
+    ClassElement E = env.getElement("E");
+    ClassElement F = env.getElement("F");
+    ClassElement G = env.getElement("G");
+
+    void checkClass(ClassElement cls,
+                    {bool directlyInstantiated: false,
+                     bool indirectlyInstantiated: false}) {
+      SubclassNode node = world.subclassNode(cls);
+      Expect.isNotNull(node, "Expected SubclassNode for $cls.");
+      Expect.equals(
+          directlyInstantiated || indirectlyInstantiated,
+          node.isInstantiated,
+          "Unexpected `isInstantiated` on SubclassNode for $cls.");
+      Expect.equals(
+          directlyInstantiated,
+          node.isDirectlyInstantiated,
+          "Unexpected `isDirectlyInstantiated` on SubclassNode for $cls.");
+      Expect.equals(
+          indirectlyInstantiated,
+          node.isIndirectlyInstantiated,
+          "Unexpected `isIndirectlyInstantiated` on SubclassNode for $cls.");
+    }
+
+
+    checkClass(A, directlyInstantiated: true, indirectlyInstantiated: true);
+    checkClass(B, indirectlyInstantiated: true);
+    checkClass(C, directlyInstantiated: true, indirectlyInstantiated: true);
+    checkClass(D, directlyInstantiated: true);
+    checkClass(E, directlyInstantiated: true);
+    checkClass(F, directlyInstantiated: true);
+    checkClass(G, directlyInstantiated: true);
+
+    SubclassNodeIterator iterator;
+
+    void checkState(
+        ClassElement root,
+        {ClassElement currentNode,
+         List<List<ClassElement>> stack}) {
+
+      ClassElement classOf(SubclassNode node) {
+        return node != null ? node.cls : null;
+      }
+
+      List<ClassElement> classesOf(Link<SubclassNode> link) {
+        if (link == null) return null;
+        return link.map(classOf).toList();
+      }
+
+      List<List<ClassElement>> listOf(Link<Link<SubclassNode>> link) {
+        if (link == null) return null;
+        return link.map(classesOf).toList();
+      }
+
+      ClassElement foundRoot = iterator.root.cls;
+      ClassElement foundCurrentNode = classOf(iterator.currentNode);
+      List<List<ClassElement>> foundStack = listOf(iterator.stack);
+
+      StringBuffer sb = new StringBuffer();
+      sb.write('{\n root: $foundRoot');
+      sb.write('\n currentNode: $currentNode');
+      sb.write('\n stack: $foundStack\n}');
+
+      Expect.equals(root, foundRoot,
+          "Expected root $root in $sb.");
+      if (currentNode == null) {
+        Expect.isNull(iterator.currentNode,
+            "Unexpected non-null currentNode in $sb.");
+      } else {
+        Expect.isNotNull(foundCurrentNode,
+            "Expected non-null currentNode ${currentNode} in $sb.");
+        Expect.equals(currentNode, foundCurrentNode,
+            "Expected currentNode $currentNode in $sb.");
+      }
+      if (stack == null) {
+        Expect.isNull(foundStack,
+            "Unexpected non-null stack in $sb.");
+      } else {
+        Expect.isNotNull(foundStack,
+            "Expected non-null stack ${stack} in $sb.");
+        Expect.equals(
+            stack.length, foundStack.length,
+            "Expected stack length ${stack.length} in $sb.");
+        for (int i = 0; i < stack.length; i++) {
+          Expect.listEquals(stack[i], foundStack[i],
+              "Expected stack level $i ${stack[i]}, "
+              "found ${foundStack[i]} in $sb.");
+        }
+      }
+    }
+
+    iterator = new SubclassNodeIterable(world.subclassNode(G)).iterator;
+    checkState(G, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(G, currentNode: G, stack: []);
+    Expect.equals(G, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(G, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(G), includeRoot: false).iterator;
+    checkState(G, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(G, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(world.subclassNode(C)).iterator;
+    checkState(C, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: C, stack: [[G, F, E]]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: G, stack: [[F, E]]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: F, stack: [[E]]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: E, stack: []);
+    Expect.equals(E, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(C, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(world.subclassNode(D)).iterator;
+    checkState(D, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(D, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(D, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(world.subclassNode(B)).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: B, stack: [[D]]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(B), includeRoot: false).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(B), directlyInstantiatedOnly: true).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(world.subclassNode(A)).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: A, stack: [[B, C]]);
+    Expect.equals(A, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: B, stack: [[D], [C]]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: [[C]]);
+    Expect.equals(D, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [[G, F, E]]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [[F, E]]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [[E]]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: []);
+    Expect.equals(E, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(A), includeRoot: false).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: B, stack: [[D], [C]]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: [[C]]);
+    Expect.equals(D, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [[G, F, E]]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [[F, E]]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [[E]]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: []);
+    Expect.equals(E, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(A), directlyInstantiatedOnly: true).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: A, stack: [[B, C]]);
+    Expect.equals(A, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: [[C]]);
+    Expect.equals(D, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [[G, F, E]]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [[F, E]]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [[E]]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: []);
+    Expect.equals(E, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new SubclassNodeIterable(
+        world.subclassNode(A),
+        includeRoot: false, directlyInstantiatedOnly: true).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: [[C]]);
+    Expect.equals(D, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [[G, F, E]]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [[F, E]]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [[E]]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: []);
+    Expect.equals(E, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+  }));
+}