Serialize TreeElements

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, 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.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/visitor.dart';
+import '../resolution/send_structure.dart';
+import '../resolution/tree_elements.dart';
+import '../tokens/token.dart';
+import '../tree/nodes.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
+import 'resolved_ast_serialization.dart';
+
 
 /// Equality based equivalence function.
 bool equality(a, b) => a == b;
 
 /// Returns `true` if the elements in [a] and [b] are pair-wise equivalent
 /// according to [elementEquivalence].
 bool areListsEquivalent(
     List a,
     List b,
     [bool elementEquivalence(a, b) = equality]) {
@@ skipping 62 matching lines @@
 }
 
 /// Returns `true` if the lists of constants, [a] and [b], are equivalent.
 bool areConstantListsEquivalent(List<ConstantExpression> a,
                                 List<ConstantExpression> b) {
   return areListsEquivalent(a, b, areConstantsEquivalent);
 }
 
 /// Returns `true` if the selectors [a] and [b] are equivalent.
 bool areSelectorsEquivalent(Selector a, Selector b) {
+  if (identical(a, b)) return true;
+  if (a == null || b == null) return false;
   return a.kind == b.kind &&
          a.callStructure == b.callStructure &&
          areNamesEquivalent(a.memberName, b.memberName);
 }
 
 /// Returns `true` if the names [a] and [b] are equivalent.
 bool areNamesEquivalent(Name a, Name b) {
   return a.text == b.text &&
          a.isSetter == b.isSetter &&
          areElementsEquivalent(a.library, b.library);
@@ skipping 23 matching lines @@
          a.isEmpty == b.isEmpty;
 }
 
 /// Returns `true` if the map literal uses [a] and [b] are equivalent.
 bool areMapLiteralUsesEquivalent(MapLiteralUse a, MapLiteralUse b) {
   return areTypesEquivalent(a.type, b.type) &&
          a.isConstant == b.isConstant &&
          a.isEmpty == b.isEmpty;
 }
 
+/// Returns `true` if the send structures [a] and [b] are equivalent.
+bool areSendStructuresEquivalent(SendStructure a, SendStructure b) {
+  if (identical(a, b)) return true;
+  if (a == null || b == null) return false;
+  if (a.kind != b.kind) return false;
+  // TODO(johnniwinther): Compute a deep equivalence.
+  return true;
+}
+
+/// Returns `true` if the new structures [a] and [b] are equivalent.
+bool areNewStructuresEquivalent(NewStructure a, NewStructure b) {
+  if (identical(a, b)) return true;
+  if (a == null || b == null) return false;
+  if (a.kind != b.kind) return false;
+  // TODO(johnniwinther): Compute a deep equivalence.
+  return true;
+}
+
 /// Strategy for testing equivalence.
 ///
 /// Use this strategy to determine equivalence without failing on inequivalence.
 class TestStrategy {
   const TestStrategy();
 
-  bool test(var object1, var object2, String property, var value1, var value2) {
-    return value1 == value2;
+  bool test(var object1, var object2, String property, var value1, var value2,
+            [bool equivalence(a, b) = equality]) {
+    return equivalence(value1, value2);
   }
 
   bool testLists(
       Object object1, Object object2, String property,
       List list1, List list2,
       [bool elementEquivalence(a, b) = equality]) {
     return areListsEquivalent(list1, list2, elementEquivalence);
   }
 
   bool testSets(
@@ skipping 389 matching lines @@
 
   @override
   bool visitPositional(PositionalArgumentReference exp1,
                   PositionalArgumentReference exp2) {
     return strategy.test(exp1, exp2, 'index', exp1.index, exp2.index);
   }
 
   @override
   bool visitSymbol(SymbolConstantExpression exp1,
                    SymbolConstantExpression exp2) {
-    // TODO: implement visitSymbol
-    return true;
+    // TODO(johnniwinther): Handle private names. Currently not even supported
+    // in resolution.
+    return strategy.test(exp1, exp2, 'name', exp1.name, exp2.name);
   }
 
   @override
   bool visitType(TypeConstantExpression exp1, TypeConstantExpression exp2) {
     return strategy.testTypes(exp1, exp2, 'type', exp1.type, exp2.type);
   }
 
   @override
   bool visitUnary(UnaryConstantExpression exp1, UnaryConstantExpression exp2) {
     return
@@ skipping 86 matching lines @@
                     StringLengthConstantExpression exp2) {
     return
         strategy.testConstants(
             exp1, exp2, 'expression',
             exp1.expression, exp2.expression);
   }
 
   @override
   bool visitDeferred(DeferredConstantExpression exp1,
                 DeferredConstantExpression exp2) {
-    // TODO: implement visitDeferred
+    // TODO(johnniwinther): Implement this.
     return true;
   }
 }
 
 /// Tests the equivalence of [impact1] and [impact2] using [strategy].
 bool testResolutionImpactEquivalence(
     ResolutionImpact impact1,
     ResolutionImpact impact2,
     [TestStrategy strategy = const TestStrategy()]) {
   return
@@ skipping 21 matching lines @@
           areMapLiteralUsesEquivalent) &&
       strategy.testSets(
           impact1, impact2, 'staticUses',
           impact1.staticUses, impact2.staticUses,
           areStaticUsesEquivalent) &&
       strategy.testSets(
           impact1, impact2, 'typeUses',
           impact1.typeUses, impact2.typeUses,
           areTypeUsesEquivalent);
 }
+
+/// Tests the equivalence of [resolvedAst1] and [resolvedAst2] using [strategy].
+bool testResolvedAstEquivalence(
+    ResolvedAst resolvedAst1,
+    ResolvedAst resolvedAst2,
+    [TestStrategy strategy = const TestStrategy()]) {
+  return
+      strategy.testElements(
+          resolvedAst1, resolvedAst2, 'element',
+        resolvedAst1.element, resolvedAst2.element) &&
+      // Compute AST equivalence by structural comparison.
+      strategy.test(
+          resolvedAst1, resolvedAst2, 'node',
+          resolvedAst1.node.toDebugString(),
+          resolvedAst2.node.toDebugString()) &&
+      testTreeElementsEquivalence(
+          resolvedAst1, resolvedAst2, strategy);
+}
+
+/// Tests the equivalence of the data stored in the [TreeElements] of
+/// [resolvedAst1] and [resolvedAst2] using [strategy].
+bool testTreeElementsEquivalence(
+    ResolvedAst resolvedAst1,
+    ResolvedAst resolvedAst2,
+    [TestStrategy strategy = const TestStrategy()]) {
+
+  AstIndexComputer indices1 = new AstIndexComputer();
+  resolvedAst1.node.accept(indices1);
+  AstIndexComputer indices2 = new AstIndexComputer();
+  resolvedAst2.node.accept(indices2);
+
+  TreeElements elements1 = resolvedAst1.elements;
+  TreeElements elements2 = resolvedAst2.elements;
+
+  TreeElementsEquivalenceVisitor visitor =
+      new TreeElementsEquivalenceVisitor(
+          indices1, indices2, elements1, elements2, strategy);
+  resolvedAst1.node.accept(visitor);
+  return visitor.success;
+}
+
+/// Visitor that checks the equivalence of [TreeElements] data.
+class TreeElementsEquivalenceVisitor extends Visitor {
+  final TestStrategy strategy;
+  final AstIndexComputer indices1;
+  final AstIndexComputer indices2;
+  final TreeElements elements1;
+  final TreeElements elements2;
+  bool success = true;
+
+  TreeElementsEquivalenceVisitor(
+      this.indices1, this.indices2,
+      this.elements1, this.elements2,
+      [this.strategy = const TestStrategy()]);
+
+  visitNode(Node node1) {
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    Node node2 = indices2.nodeList[index];
+    success =
+        strategy.testElements(
+            node1, node2, '[$index]',
+            elements1[node1], elements2[node2]) &&
+        strategy.testTypes(
+            node1, node2, 'getType($index)',
+            elements1.getType(node1), elements2.getType(node2)) &&
+        strategy.test(
+            node1, node2, 'getSelector($index)',
+            elements1.getSelector(node1), elements2.getSelector(node2),
+            areSelectorsEquivalent) &&
+        strategy.testConstants(
+            node1, node2, 'getConstant($index)',
+            elements1.getConstant(node1), elements2.getConstant(node2)) &&
+        strategy.testTypes(
+            node1, node2, 'typesCache[$index]',
+            elements1.typesCache[node1], elements2.typesCache[node2]);
+
+    node1.visitChildren(this);
+  }
+
+  @override
+  visitSend(Send node1) {
+    visitExpression(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    Send node2 = indices2.nodeList[index];
+    success =
+        strategy.test(
+            node1, node2, 'isTypeLiteral($index)',
+            elements1.isTypeLiteral(node1),
+            elements2.isTypeLiteral(node2)) &&
+        strategy.testTypes(
+            node1, node2, 'getTypeLiteralType($index)',
+            elements1.getTypeLiteralType(node1),
+            elements2.getTypeLiteralType(node2)) &&
+        strategy.test(
+            node1, node2, 'getSendStructure($index)',
+            elements1.getSendStructure(node1),
+            elements2.getSendStructure(node2),
+            areSendStructuresEquivalent);
+  }
+
+  @override
+  visitNewExpression(NewExpression node1) {
+    visitExpression(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    NewExpression node2 = indices2.nodeList[index];
+    success =
+        strategy.test(
+            node1, node2, 'getNewStructure($index)',
+            elements1.getNewStructure(node1),
+            elements2.getNewStructure(node2),
+            areNewStructuresEquivalent);
+  }
+
+  @override
+  visitSendSet(SendSet node1) {
+    visitSend(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    SendSet node2 = indices2.nodeList[index];
+    success =
+        strategy.test(
+            node1, node2, 'getGetterSelectorInComplexSendSet($index)',
+            elements1.getGetterSelectorInComplexSendSet(node1),
+            elements2.getGetterSelectorInComplexSendSet(node2),
+            areSelectorsEquivalent) &&
+        strategy.test(
+            node1, node2, 'getOperatorSelectorInComplexSendSet($index)',
+            elements1.getOperatorSelectorInComplexSendSet(node1),
+            elements2.getOperatorSelectorInComplexSendSet(node2),
+            areSelectorsEquivalent);
+  }
+
+  @override
+  visitFunctionExpression(FunctionExpression node1) {
+    visitNode(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    FunctionExpression node2 = indices2.nodeList[index];
+    if (elements1[node1] is! FunctionElement) {
+      // [getFunctionDefinition] is currently stored in [] which doesn't always
+      // contain a [FunctionElement].
+      return;
+    }
+    success =
+        strategy.testElements(
+            node1, node2, 'getFunctionDefinition($index)',
+            elements1.getFunctionDefinition(node1),
+            elements2.getFunctionDefinition(node2));
+  }
+
+  @override
+  visitForIn(ForIn node1) {
+    visitLoop(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    ForIn node2 = indices2.nodeList[index];
+    success =
+        strategy.testElements(
+            node1, node2, 'getForInVariable($index)',
+            elements1.getForInVariable(node1),
+            elements2.getForInVariable(node2));
+  }
+
+  @override
+  visitRedirectingFactoryBody(RedirectingFactoryBody node1) {
+    visitStatement(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    RedirectingFactoryBody node2 = indices2.nodeList[index];
+    success =
+        strategy.testElements(
+            node1, node2, 'getRedirectingTargetConstructor($index)',
+            elements1.getRedirectingTargetConstructor(node1),
+            elements2.getRedirectingTargetConstructor(node2));
+  }
+}