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]) {
   if (a.length != b.length) return false;
   for (int i = 0; i < a.length && i < b.length; i++) {
@@ skipping 57 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 21 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(
       var object1, var object2, String property, Iterable set1, Iterable set2,
@@ skipping 324 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 strategy.test(
@@ skipping 67 matching lines @@
   @override
   bool visitStringLength(StringLengthConstantExpression exp1,
       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 strategy.testSets(impact1, impact2, 'constSymbolNames',
           impact1.constSymbolNames, impact2.constSymbolNames) &&
@@ skipping 10 matching lines @@
           impact1, impact2, 'features', impact1.features, impact2.features) &&
       strategy.testSets(impact1, impact2, 'listLiterals', impact1.listLiterals,
           impact2.listLiterals, areListLiteralUsesEquivalent) &&
       strategy.testSets(impact1, impact2, 'mapLiterals', impact1.mapLiterals,
           impact2.mapLiterals, 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));
+  }
+}