Add equivalence testing on JS nodes to support different label names

tests/compiler/dart2js/kernel/compile_from_dill_test_helper.dart

 // Copyright (c) 2017, 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.
 
 // Helper to test compilation equivalence between source and .dill based
 // compilation.
 library dart2js.kernel.compile_from_dill_test_helper;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:compiler/compiler_new.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/kernel/element_map.dart';
 import 'package:compiler/src/kernel/kernel_strategy.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/resolution/enum_creator.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/world.dart';
 import 'package:expect/expect.dart';
 import '../memory_compiler.dart';
 import '../equivalence/check_functions.dart';
 import '../equivalence/check_helpers.dart';
+import '../serialization/helper.dart';
 import 'test_helpers.dart';
 
 import 'compiler_helper.dart';
 
-const SOURCE = const {
-  'main.dart': '''
+class Test {
+  final Uri uri;
+  final Map<String, String> sources;
+  final bool expectIdenticalOutput;
+
+  const Test(this.sources, {this.expectIdenticalOutput: true}) : uri = null;
+
+  Test.fromUri(this.uri, {this.expectIdenticalOutput: true})
+      : sources = const {};
+
+  Uri get entryPoint => uri ?? Uri.parse('memory:main.dart');
+
+  String toString() => uri != null ? '$uri' : sources.values.first;
+}
+
+const List<Test> TESTS = const <Test>[
+  const Test(const {
+    'main.dart': '''
 import 'dart:html';
 
 foo({named}) => 1;
 bar(a) => !a;
 class Class {
   var field;
   static var staticField;
 
   Class();
   Class.named(this.field);
@@ skipping 36 matching lines @@
     x = i;
     if (i == 7) break;
     i++;
   }
   for (var v in [3, 5]) {
     if (v == 5) continue;
     x = v;
     if (v == 7) break;
   }
   do {
-    // TODO(johnniwinther): Support js ast equivalence to handle label name
-    // mismatches. Enable the continue test:
-    //if (i == 5) continue;

[Siggi Cherem (dart-lang), 2017/06/30 22:24:01]

did you mean to keep the `if (i == 5) continue;` statement?

[Johnni Winther, 2017/07/03 08:01:02]

No. It requires labels which is why it is move the the next test.

     x = i;
     if (i == 7) break;
     i++;
   } while (i < 10);
   switch (x) {
   case 0:
     x = 7;
     break;
   case 1:
     x = 9;
     break;
   default:
     x = 11;
     break;
   }
   x = toplevel;
   print(x);
   return x;
 }
 '''
-};
+  }),
+  const Test(const {
+    'main.dart': ''' 
+
+main() {
+  var x;
+  int i = 0;
+  do {
+    if (i == 5) continue;
+    x = i;
+    if (i == 7) break;
+    i++;
+  } while (i < 10);
+  print(x);
+} 
+'''
+  }, expectIdenticalOutput: false),
+];
 
 enum ResultKind { crashes, errors, warnings, success, failure }
 
 const List<String> commonOptions = const <String>[
   Flags.disableTypeInference,
   Flags.disableInlining,
   Flags.enableAssertMessage
 ];
 
+Future runTests(List<String> args,
+    {bool skipWarnings: false,
+    bool skipErrors: false,
+    List<String> options: const <String>[]}) async {
+  Arguments arguments = new Arguments.from(args);
+  List<Test> tests;
+  if (arguments.uri != null) {
+    tests = <Test>[new Test.fromUri(arguments.uri)];
+  } else {
+    tests = TESTS;
+  }
+  for (Test test in tests) {
+    if (test.uri != null) {
+      print('--- running test uri ${test.uri} -------------------------------');
+    } else {
+      print(
+          '--- running test code -------------------------------------------');
+      print(test.sources.values.first);
+      print('----------------------------------------------------------------');
+    }
+    await runTest(test.entryPoint, test.sources,
+        verbose: arguments.verbose,
+        skipWarnings: skipWarnings,
+        skipErrors: skipErrors,
+        options: options,
+        expectIdenticalOutput: test.expectIdenticalOutput);
+  }
+}
+
 Future<ResultKind> runTest(
     Uri entryPoint, Map<String, String> memorySourceFiles,
     {bool skipWarnings: false,
     bool skipErrors: false,
     bool verbose: false,
-    List<String> options: const <String>[]}) async {
+    List<String> options: const <String>[],
+    bool expectIdenticalOutput: true}) async {
   enableDebugMode();
   EnumCreator.matchKernelRepresentationForTesting = true;
   Elements.usePatchedDart2jsSdkSorting = true;
 
   Directory dir = await Directory.systemTemp.createTemp('dart2js-with-dill');
   print('--- create temp directory $dir -------------------------------');
   memorySourceFiles.forEach((String name, String source) {
     new File.fromUri(dir.uri.resolve(name)).writeAsStringSync(source);
   });
   entryPoint = dir.uri.resolve(entryPoint.path);
@@ skipping 74 matching lines @@
       elementFilter: elementFilter,
       verbose: verbose);
 
   checkEmitters(compiler1.backend.emitter, compiler2.backend.emitter,
       elementEquivalence: (a, b) => equivalence.entityEquivalence(a, b),
       typeEquivalence: (DartType a, DartType b) {
         return equivalence.typeEquivalence(unalias(a), b);
       },
       verbose: verbose);
 
-  print('--- checking output------- -----------------------------------------');
-  collector1.outputMap
-      .forEach((OutputType outputType, Map<String, BufferedOutputSink> map1) {
-    if (outputType == OutputType.sourceMap) {
-      // TODO(johnniwinther): Support source map from .dill.
-      return;
-    }
-    Map<String, BufferedOutputSink> map2 = collector2.outputMap[outputType];
-    checkSets(map1.keys, map2.keys, 'output', equality);
-    map1.forEach((String name, BufferedOutputSink output1) {
-      BufferedOutputSink output2 = map2[name];
-      Expect.stringEquals(output1.text, output2.text);
+  checkGeneratedCode(compiler1.backend, compiler2.backend,
+      elementEquivalence: (a, b) => equivalence.entityEquivalence(a, b));
+
+  if (expectIdenticalOutput) {
+    print('--- checking output------- ---------------------------------------');
+    collector1.outputMap
+        .forEach((OutputType outputType, Map<String, BufferedOutputSink> map1) {
+      if (outputType == OutputType.sourceMap) {
+        // TODO(johnniwinther): Support source map from .dill.
+        return;
+      }
+      Map<String, BufferedOutputSink> map2 = collector2.outputMap[outputType];
+      checkSets(map1.keys, map2.keys, 'output', equality);
+      map1.forEach((String name, BufferedOutputSink output1) {
+        BufferedOutputSink output2 = map2[name];
+        Expect.stringEquals(output1.text, output2.text);
+      });
     });
-  });
+  }
   return ResultKind.success;
 }