Store and serialize NativeBehavior in 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 '../js_backend/backend_serialization.dart'
+    show JavaScriptBackendSerializer;
+import '../native/native.dart' show NativeBehavior;
 import '../resolution/access_semantics.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 '../util/util.dart';
 import 'resolved_ast_serialization.dart';
 
@@ skipping 797 matching lines @@
             indices2.nodeIndices[b.label]) &&
         strategy.test(a, b, 'labelName', a.labelName, b.labelName) &&
         strategy.test(a, b, 'target', indices1.nodeIndices[a.target.statement],
             indices2.nodeIndices[b.target.statement]) &&
         strategy.test(
             a, b, 'isBreakTarget', a.isBreakTarget, b.isBreakTarget) &&
         strategy.test(
             a, b, 'isContinueTarget', a.isContinueTarget, b.isContinueTarget);
   }
 
+  bool testNativeData(Node node1, Node node2, String property, a, b) {
+    if (identical(a, b)) return true;
+    if (a == null || b == null) return false;
+    if (a is NativeBehavior && b is NativeBehavior) {
+      return strategy.test(a, b, 'codeTemplateText', a.codeTemplateText,
+              b.codeTemplateText) &&
+          strategy.test(a, b, 'isAllocation', a.isAllocation, b.isAllocation) &&
+          strategy.test(a, b, 'sideEffects', a.sideEffects, b.sideEffects) &&
+          strategy.test(
+              a, b, 'throwBehavior', a.throwBehavior, b.throwBehavior) &&
+          strategy.testTypeLists(
+              a,
+              b,
+              'dartTypesReturned',
+              JavaScriptBackendSerializer.filterDartTypes(a.typesReturned),
+              JavaScriptBackendSerializer.filterDartTypes(b.typesReturned)) &&
+          strategy.testLists(
+              a,
+              b,
+              'specialTypesReturned',
+              JavaScriptBackendSerializer.filterSpecialTypes(a.typesReturned),
+              JavaScriptBackendSerializer
+                  .filterSpecialTypes(b.typesReturned)) &&
+          strategy.testTypeLists(
+              a,
+              b,
+              'dartTypesInstantiated',
+              JavaScriptBackendSerializer.filterDartTypes(a.typesInstantiated),
+              JavaScriptBackendSerializer
+                  .filterDartTypes(b.typesInstantiated)) &&
+          strategy.testLists(
+              a,
+              b,
+              'specialTypesInstantiated',
+              JavaScriptBackendSerializer
+                  .filterSpecialTypes(a.typesInstantiated),
+              JavaScriptBackendSerializer
+                  .filterSpecialTypes(b.typesInstantiated)) &&
+          strategy.test(a, b, 'useGvn', a.useGvn, b.useGvn);
+    }
+    return true;
+  }
+
   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]) &&
         testJumpTargets(
             node1,
             node2,
             'getTargetDefinition($index)',
             elements1.getTargetDefinition(node1),
-            elements2.getTargetDefinition(node2));
+            elements2.getTargetDefinition(node2)) &&
+        testNativeData(node1, node2, 'getNativeData($index)',
+            elements1.getNativeData(node1), elements2.getNativeData(node2));
 
     node1.visitChildren(this);
   }
 
   @override
   visitSend(Send node1) {
     visitExpression(node1);
     if (!success) return;
     int index = indices1.nodeIndices[node1];
     Send node2 = indices2.nodeList[index];
@@ skipping 823 matching lines @@
   @override
   bool visitStatement(Statement node1, Statement node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 
   @override
   bool visitStringNode(StringNode node1, StringNode node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 }