dart2dart compiler support.

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 33 matching lines @@
    * test in the suite.  When all tests have been processed, call [onDone].
    *
    * The [testCache] argument provides a persistent store that can be used to
    * cache information about the test suite, so that directories do not need
    * to be listed each time.
    */
   void forEachTest(Function onTest, Map testCache, [Function onDone]);
 }
 
 
+// TODO(1030): remove once in the corelib.
+bool Contains(element, collection) => collection.indexOf(element) >= 0;
+
+
 class CCTestListerIsolate extends Isolate {
   CCTestListerIsolate() : super.heavy();
 
   void main() {
     port.receive((String runnerPath, SendPort replyTo) {
       var p = Process.start(runnerPath, ["--list"]);
       StringInputStream stdoutStream = new StringInputStream(p.stdout);
       List<String> tests = new List<String>();
       stdoutStream.onLine = () {
         String line = stdoutStream.readLine();
@@ skipping 362 matching lines @@
                           makeCommands(info, args),
                           configuration,
                           completeHandler,
                           expectations,
                           isNegative,
                           info));
     }
   }
 
   List<Command> makeCommands(TestInformation info, var args) {
-    if (configuration['compiler'] == 'dart2js') {
+    switch (configuration['compiler']) {
+    case 'dart2js':
       args = new List.from(args);
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.js');
       List<Command> commands = <Command>[new Command(shellPath(), args)];
       if (configuration['runtime'] == 'd8') {
         var d8 = TestUtils.d8FileName(configuration);
         commands.add(new Command(d8, ['$tempDir/out.js']));
       }
       return commands;
-    } else {
+
+    case 'dart2dart':
+      args = new List.from(args);
+      args.add('--output-type=dart');
+      String tempDir = createOutputDirectory(info.filePath, '');
+      args.add('--out=$tempDir/out.dart');
+      List<Command> commands = <Command>[new Command(shellPath(), args)];
+      if (configuration['runtime'] == 'vm') {
+        // TODO(antonm): support checked.
+        commands.add(new Command(
+            TestUtils.vmFileName(configuration),
+            ['--enable_checked_mode', '$tempDir/out.dart']));
+      } else {
+        throw 'Unsupported runtime ${configuration["runtime"]} for dart2dart';
+      }
+      return commands;
+
+    default:
       return <Command>[new Command(shellPath(), args)];
     }
   }
 
   Function makeTestCaseCreator(Map optionsFromFile) {
     return (Path filePath,
             bool isNegative,
             [bool isNegativeIfChecked = false,
              bool hasFatalTypeErrors = false,
              bool hasRuntimeErrors = false,
@@ skipping 175 matching lines @@
             '--out=$htmlPath'];
         if (runtime == 'dartium') {
           args.add('--executable=$dartiumFilename');
         }
       } else {
         args = [
             dartDir.append('tools/testing/drt-trampoline.py').toNativePath(),
             dumpRenderTreeFilename,
             '--no-timeout'
         ];
-        if (runtime == 'drt' && compiler == 'none') {
+        if (runtime == 'drt' &&
+            (compiler == 'none' || compiler == 'dart2dart')) {
           var dartFlags = ['--ignore-unrecognized-flags'];
           if (configuration["checked"]) {
             dartFlags.add('--enable_asserts');
             dartFlags.add("--enable_type_checks");
           }
           dartFlags.addAll(vmOptions);
           args.add('--dart-flags=${Strings.join(dartFlags, " ")}');
         }
         args.add(htmlPath);
         if (expectedOutput != null) {
@@ skipping 21 matching lines @@
         if (libdir == '') {
           libdir = dartDir.append('frog/lib').toNativePath();
         }
         args.addAll(['--libdir=$libdir',
                      '--compile-only',
                      '--out=$outputFile']);
         args.addAll(vmOptions);
         args.add(inputFile);
         break;
       case 'dart2js':
+      case 'dart2dart':
+        if (compiler == 'dart2dart') args.add('--out=$outputFile');
         args.add('--out=$outputFile');
         args.add(inputFile);
         break;
       default:
         Expect.fail('unimplemented compiler $compiler');
     }
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insertRange(0, 1, executable);
       executable = TestUtils.dartShellFileName(configuration);
@@ skipping 30 matching lines @@
          "${configuration['compiler']}-${configuration['runtime']}",
          testUniqueName], '/');
 
     TestUtils.mkdirRecursive(new Path('.'), new Path(generatedTestPath));
     return new File(generatedTestPath).fullPathSync().replaceAll('\\', '/');
   }
 
   String get scriptType() {
     switch (configuration['compiler']) {
       case 'none':
+      case 'dart2dart':
         return 'application/dart';
       case 'frog':
       case 'dart2js':
       case 'dartc':
         return 'text/javascript';
       default:
         Expect.fail('Non-web runtime, so no scriptType for: '
                     '${configuration["compiler"]}');
         return null;
     }
@@ skipping 482 matching lines @@
   }
 
   static String executableName(Map configuration) {
     String suffix = executableSuffix(configuration['compiler']);
     switch (configuration['compiler']) {
       case 'none':
         return 'dart$suffix';
       case 'dartc':
         return 'analyzer/bin/dart_analyzer$suffix';
       case 'dart2js':
+      case 'dart2dart':
         var prefix = '';
         if (configuration['use_sdk']) {
           prefix = 'dart-sdk/bin/';
         }
         if (configuration['host_checked']) {
           // The script dart2js_developer is not in the SDK.
           return 'dart2js_developer$suffix';
         } else {
           return '${prefix}dart2js$suffix';
         }
       case 'frog':
         return 'frog/bin/frog$suffix';
       default:
         throw "Unknown executable for: ${configuration['compiler']}";
     }
   }
 
   static String compilerName(Map configuration) {
     String suffix = executableSuffix(configuration['compiler']);
     switch (configuration['compiler']) {
       case 'dartc':
       case 'dart2js':
+      case 'dart2dart':
         return executableName(configuration);
       case 'frog':
         return 'frog/bin/frog$suffix';
       default:
         throw "Unknown compiler for: ${configuration['compiler']}";
     }
   }
 
   static String dartShellFileName(Map configuration) {
     var name = configuration['dart'];
     if (name == '') {
       name = '${buildDir(configuration)}/${executableName(configuration)}';
     }
     ensureExists(name, configuration);
     return name;
   }
 
   static String d8FileName(Map configuration) {
     var suffix = executableSuffix('d8');
     var d8 = '${buildDir(configuration)}/d8$suffix';
     ensureExists(d8, configuration);
     return d8;
   }
 
+  static String vmFileName(Map configuration) {
+    var suffix = executableSuffix('vm');
+    var vm = '${buildDir(configuration)}/dart$suffix';
+    ensureExists(vm, configuration);
+    return vm;
+  }
+
   static void ensureExists(String filename, Map configuration) {
     if (!configuration['list'] && !(new File(filename).existsSync())) {
       throw "Executable '$filename' does not exist";
     }
   }
 
   static String compilerPath(Map configuration) {
     if (configuration['compiler'] == 'none') {
       return null;  // No separate compiler for dartium tests.
     }
@@ skipping 29 matching lines @@
     Path scriptPath = new Path.fromNative(scriptFile.fullPathSync());
     return scriptPath.directoryPath.directoryPath;
   }
 
   static List<String> standardOptions(Map configuration) {
     List args = ["--ignore-unrecognized-flags"];
     if (configuration["checked"]) {
       args.add('--enable_asserts');
       args.add("--enable_type_checks");
     }
-    if (configuration["compiler"] == "dart2js") {
+    String compiler = configuration["compiler"];
+    if (compiler == "dart2js" || compiler == "dart2dart") {
       args = [];
       if (configuration["checked"]) {
         args.add('--enable-checked-mode');
       }
-      args.add("--verbose");
+      // args.add("--verbose");
       if (!isBrowserRuntime(configuration['runtime'])) {
         args.add("--allow-mock-compilation");
       }
     }
     return args;
   }
 
-  static bool isBrowserRuntime(String runtime) =>
+  static bool isBrowserRuntime(String runtime) => Contains(
+      runtime,
       const <String>['drt',
                      'dartium',
                      'ie',
                      'safari',
                      'opera',
                      'chrome',
-                     'ff'].indexOf(runtime) != -1;
+                     'ff']);
 }
 
 class SummaryReport {
   static int total = 0;
   static int skipped = 0;
   static int noCrash = 0;
   static int pass = 0;
   static int failOk = 0;
   static int fail = 0;
   static int crash = 0;
@@ skipping 33 matching lines @@
  * $noCrash tests are expected to be flaky but not crash
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
 """;
     print(report);
    }
 }