Change default binary file extension to .dill

test/kernel/kernel_test.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.md file.
 
 library rasta.dart2js_test;
 
 import 'dart:async' show
     Future,
     Stream;
 
@@ skipping 29 matching lines @@
 import 'package:rasta/src/rastask.dart' show
     Rastask,
     openWrite;
 
 import 'package:rasta/src/options.dart' show
     Options;
 
 const bool generateExpectations =
     const bool.fromEnvironment("generateExpectations");
 
+const String dartExtension = ".dart";
+const String kernelExtension = ".dill";
+
 Future<Null> addRegressions(Map<Uri, Uri> tests, Uri temp) async {
   Stream<TestDescription> regressions = listTests(
-      <Uri>[Uri.base.resolve("test/kernel/regression/")], pattern: ".dart");
+      <Uri>[Uri.base.resolve("test/kernel/regression/")],
+      pattern: dartExtension);
   await for (TestDescription regression in regressions) {
-    tests[regression.uri] = temp.resolve("${regression.shortName}.bart");
+    tests[regression.uri] =
+        temp.resolve("${regression.shortName}$kernelExtension");
   }
 }
 
 Future<Null> main() async {
   Stopwatch wallClock = new Stopwatch()..start();
   Rastask task = await Rastask.create(
       wallClock, <String>["--library", "${Platform.script}"]);
   await task.measureSubtask("runTests", () => runTests(task));
 }
 
 Future<Null> runTests(Rastask task) async {
   await task.setup();
 
   // When running via `testa.dart`, [Platform.script] is located in a temporary
   // directory.
   Uri temp = Platform.script;
   Map<Uri, Uri> tests = <Uri, Uri>{
-    Uri.parse("dart:core"): temp.resolve("core.bart"),
+    Uri.parse("dart:core"): temp.resolve("core$kernelExtension"),
 
-    Uri.parse("package:compiler/src/dart2js.dart"):
-    temp.resolve("dart2js.bart"),
+    Uri.parse("package:compiler/src/dart2js$dartExtension"):
+    temp.resolve("dart2js$kernelExtension"),
   };
 
   await addRegressions(tests, temp);
 
   Uri statusFile = Uri.base.resolve("test/rasta.status");
   TestExpectations expectations =
       await ReadTestExpectations(<String>[statusFile.toFilePath()], {});
 
   List<Uri> fails = <Uri>[];
 
   for (Uri source in tests.keys) {
     assert(task.kernel.isInternalStateConsistent);
 
     bool isRegression = source.path.contains("/regression/");
 
     print("Rastarizing $source");
-    Uri bart = tests[source];
-    File output = new File.fromUri(bart);
+    Uri dill = tests[source];
+    File output = new File.fromUri(dill);
     await output.parent.create(recursive: true);
 
     Options options = new Options(
-        source, bart, dependenciesFile: null,
+        source, dill, dependenciesFile: null,
         generateLibrary: isRegression ? isRegression : null,
         isVerbose: true, isBatch: false, pattern: null);
 
     ir.TreeNode node;
     Expectation outcome = Expectation.PASS;
     var error;
     StackTrace trace;
     try {
       node = await task.runOne(options);
     } catch (e, t) {
       outcome = Expectation.CRASH;
       task.kernel.recoverFromCrash();
       error = e;
       trace = t;
     }
 
     if (isRegression && outcome == Expectation.PASS) {
       outcome = await checkAgainstExpectations(node);
     }
     if (outcome == Expectation.PASS) {
-      outcome = checkRoundTrip(bart);
+      outcome = checkRoundTrip(dill);
     }
 
     Set<Expectation> expectedOutcomes = isRegression
         ? expectations.expectations(
             relativize(statusFile.resolve("."), source, false))
         : <Expectation>[Expectation.PASS].toSet();
 
     if (!expectedOutcomes.contains(outcome)) {
       print("$source: '$outcome' isn't one of '$expectedOutcomes'.");
       if (error != null) print(error);
@@ skipping 52 matching lines @@
   ir.TreeNode programOrLibrary =
       new BinaryLoader(repository).loadProgramOrLibrary("$uri");
   Printer printer = new Printer(new StringBuffer());
   if (programOrLibrary is ir.Program) {
     printer.writeProgramFile(programOrLibrary);
   } else {
     printer.writeLibraryFile(programOrLibrary);
   }
   return Expectation.PASS;
 }