Serialize JumpTarget and LabelDefinition.

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';
@@ skipping 772 matching lines @@
   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()]);
 
+  bool testJumpTargets(
+      Node node1, Node node2, String property, JumpTarget a, JumpTarget b) {
+    if (identical(a, b)) return true;
+    if (a == null || b == null) return false;
+    return strategy.testElements(a, b, 'executableContext', a.executableContext,
+            b.executableContext) &&
+        strategy.test(a, b, 'nestingLevel', a.nestingLevel, b.nestingLevel) &&
+        strategy.test(a, b, 'statement', indices1.nodeIndices[a.statement],
+            indices2.nodeIndices[b.statement]) &&
+        strategy.test(
+            a, b, 'isBreakTarget', a.isBreakTarget, b.isBreakTarget) &&
+        strategy.test(
+            a, b, 'isContinueTarget', a.isContinueTarget, b.isContinueTarget) &&
+        strategy.testLists(a, b, 'labels', a.labels.toList(), b.labels.toList(),
+            (a, b) {
+          return indices1.nodeIndices[a.label] == indices2.nodeIndices[b.label];
+        });
+  }
+
+  bool testLabelDefinitions(Node node1, Node node2, String property,
+      LabelDefinition a, LabelDefinition b) {
+    if (identical(a, b)) return true;
+    if (a == null || b == null) return false;
+    return strategy.test(a, b, 'label', indices1.nodeIndices[a.label],
+            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);
+  }
+
   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]);
+            elements1.typesCache[node1], elements2.typesCache[node2]) &&
+        testJumpTargets(
+            node1,
+            node2,
+            'getTargetDefinition($index)',
+            elements1.getTargetDefinition(node1),
+            elements2.getTargetDefinition(node2));
 
     node1.visitChildren(this);
   }
 
   @override
   visitSend(Send node1) {
     visitExpression(node1);
     if (!success) return;
     int index = indices1.nodeIndices[node1];
     Send node2 = indices2.nodeList[index];
@@ skipping 86 matching lines @@
     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));
   }
+
+  @override
+  visitGotoStatement(GotoStatement node1) {
+    visitStatement(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    GotoStatement node2 = indices2.nodeList[index];
+    success = testJumpTargets(node1, node2, 'getTargetOf($index)',
+        elements1.getTargetOf(node1), elements2.getTargetOf(node2));
+    if (!success) return;
+    if (node1.target == null && node2.target == null) {
+      return;
+    }
+    success = testLabelDefinitions(node1, node2, 'getTarget($index)',
+        elements1.getTargetLabel(node1), elements2.getTargetLabel(node2));
+  }
+
+  @override
+  visitLabel(Label node1) {
+    visitNode(node1);
+    if (!success) return;
+    int index = indices1.nodeIndices[node1];
+    Label node2 = indices2.nodeList[index];
+    success = testLabelDefinitions(
+        node1,
+        node2,
+        'getLabelDefinition($index)',
+        elements1.getLabelDefinition(node1),
+        elements2.getLabelDefinition(node2));
+  }
 }
 
 class NodeEquivalenceVisitor implements Visitor1<bool, Node> {
   final TestStrategy strategy;
 
   const NodeEquivalenceVisitor([this.strategy = const TestStrategy()]);
 
   bool testNodes(
       var object1, var object2, String property, Node node1, Node node2) {
     if (node1 == node2) return true;
@@ skipping 687 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');
   }
 }