Rename fletch -> dartino

tests/dartino_compiler/incremental/feature_test.dart

 // Copyright (c) 2014, 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.
 
-library fletchc.test.feature_test;
+library dartino_compiler.test.feature_test;
 
 import 'dart:io' hide
     exitCode,
     stderr,
     stdin,
     stdout;
 
 import 'dart:io' as io;
 
 import 'dart:async' show
     Completer,
     Future,
     Stream,
     StreamController,
     StreamIterator;
 
 import 'dart:convert' show
     LineSplitter,
     UTF8,
     Utf8Decoder;
 
 import 'package:expect/expect.dart' show
     Expect;
 
-import 'package:fletchc/incremental/scope_information_visitor.dart' show
+import 'package:dartino_compiler/incremental/scope_information_visitor.dart' show
     ScopeInformationVisitor;
 
 import 'compiler_test_case.dart' show
     CompilerTestCase;
 
 import 'package:compiler/src/elements/elements.dart' show
     AbstractFieldElement,
     Element,
     FieldElement,
     FunctionElement,
     LibraryElement;
 
 import 'package:compiler/src/compiler.dart' show
     Compiler;
 
 import 'package:compiler/src/source_file_provider.dart' show
     FormattingDiagnosticHandler,
     SourceFileProvider;
 
 import 'package:compiler/src/io/source_file.dart' show
     StringSourceFile;
 
-import 'package:fletchc/incremental/fletchc_incremental.dart' show
+import 'package:dartino_compiler/incremental/dartino_compiler_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalCompiler,
     IncrementalMode;
 
-import 'package:fletchc/vm_commands.dart' show
+import 'package:dartino_compiler/vm_commands.dart' show
     VmCommand,
     CommitChanges,
     CommitChangesResult,
     HandShakeResult,
     MapId;
 
-import 'package:fletchc/fletch_compiler.dart' show
-    FletchCompiler;
+import 'package:dartino_compiler/dartino_compiler.dart' show
+    DartinoCompiler;
 
-import 'package:fletchc/src/fletch_compiler_implementation.dart' show
+import 'package:dartino_compiler/src/dartino_compiler_implementation.dart' show
     OutputProvider;
 
-import 'package:fletchc/src/guess_configuration.dart' show
-    fletchVersion,
-    guessFletchVm;
+import 'package:dartino_compiler/src/guess_configuration.dart' show
+    dartinoVersion,
+    guessDartinoVm;
 
-import 'package:fletchc/fletch_system.dart';
+import 'package:dartino_compiler/dartino_system.dart';
 
-import 'package:fletchc/vm_commands.dart' as commands_lib;
+import 'package:dartino_compiler/vm_commands.dart' as commands_lib;
 
-import 'package:fletchc/vm_session.dart' show
+import 'package:dartino_compiler/vm_session.dart' show
     Session;
 
-import 'package:fletchc/src/fletch_backend.dart' show
-    FletchBackend;
+import 'package:dartino_compiler/src/dartino_backend.dart' show
+    DartinoBackend;
 
-import 'package:fletchc/fletch_vm.dart' show
-    FletchVm;
+import 'package:dartino_compiler/dartino_vm.dart' show
+    DartinoVm;
 
-import 'package:fletchc/debug_state.dart' as debug show
+import 'package:dartino_compiler/debug_state.dart' as debug show
     BackTraceFrame,
     BackTrace;
 
 import 'program_result.dart';
 
-import 'package:fletchc/src/hub/exit_codes.dart' show
+import 'package:dartino_compiler/src/hub/exit_codes.dart' show
     DART_VM_EXITCODE_COMPILE_TIME_ERROR;
 
-const String PACKAGE_SCHEME = 'org.dartlang.fletch.packages';
+const String PACKAGE_SCHEME = 'org.dartlang.dartino.packages';
 
-const String CUSTOM_SCHEME = 'org.dartlang.fletch.test-case';
+const String CUSTOM_SCHEME = 'org.dartlang.dartino.test-case';
 
 final Uri customUriBase = new Uri(scheme: CUSTOM_SCHEME, path: '/');
 
 typedef Future NoArgFuture();
 
 compileAndRun(
     String testName,
     EncodedResult encodedResult,
     {IncrementalMode incrementalMode}) async {
   print("Test '$testName'");
@@ skipping 14 matching lines @@
       if (!program.compileUpdatesShouldThrow) {
         // We should only update the status of hasCompileTimeError when we run
         // something on the VM.
         hasCompileTimeError = program.hasCompileTimeError;
       }
 
       print("Program version $version #$testName:");
       print(numberedLines(program.code));
 
       bool compileUpdatesThrew = true;
-      FletchDelta fletchDelta;
+      DartinoDelta dartinoDelta;
       if (isFirstProgram) {
         // The first program is compiled "fully".
-        fletchDelta = await helper.fullCompile(program);
+        dartinoDelta = await helper.fullCompile(program);
         compileUpdatesThrew = false;
       } else {
         // An update to the first program, all updates are compiled as
         // incremental updates to the first program.
         try {
-          fletchDelta = await helper.incrementalCompile(program, version);
+          dartinoDelta = await helper.incrementalCompile(program, version);
           compileUpdatesThrew = false;
         } on IncrementalCompilationFailed catch (error) {
           if (program.compileUpdatesShouldThrow) {
             print("Expected error in compileUpdates: $error");
           } else {
             print("Unexpected error in compileUpdates.");
             rethrow;
           }
         }
       }
 
-      FletchBackend backend = helper.compiler.compiler.context.backend;
+      DartinoBackend backend = helper.compiler.compiler.context.backend;
 
       if (program.compileUpdatesShouldThrow) {
         Expect.isFalse(isFirstProgram);
         Expect.isTrue(
             compileUpdatesThrew,
             "Expected an exception in compileUpdates");
-        Expect.isNull(fletchDelta, "Expected update == null");
+        Expect.isNull(dartinoDelta, "Expected update == null");
         break;
       }
 
       if (!isFirstProgram ||
           const bool.fromEnvironment("feature_test.print_initial_commands")) {
-        for (VmCommand command in fletchDelta.commands) {
+        for (VmCommand command in dartinoDelta.commands) {
           print(command);
         }
       }
 
       if (isFirstProgram) {
         // Perform handshake with VM.
         HandShakeResult handShakeResult =
-            await session.handShake(fletchVersion);
-        Expect.isTrue(handShakeResult.success, "Fletch VM version mismatch");
+            await session.handShake(dartinoVersion);
+        Expect.isTrue(handShakeResult.success, "Dartino VM version mismatch");
       }
 
-      CommitChangesResult result = await session.applyDelta(fletchDelta);
+      CommitChangesResult result = await session.applyDelta(dartinoDelta);
 
       if (!result.successful) {
         print("The CommitChanges() command was not successful: "
               "${result.message}");
       }
 
       Expect.equals(result.successful, !program.commitChangesShouldFail,
                     result.message);
 
       if (isFirstProgram) {
@@ skipping 26 matching lines @@
           await session.restart();
         }
         if (session.running) {
           // Step out of main to finish execution of main.
           await session.stepOut();
         }
 
         // Select the stack frame of callMain.
         debug.BackTrace trace = await session.backTrace();
         FunctionElement callMainElement =
-            backend.fletchSystemLibrary.findLocal("callMain");
-        FletchFunction callMain =
+            backend.dartinoSystemLibrary.findLocal("callMain");
+        DartinoFunction callMain =
             helper.system.lookupFunctionByElement(callMainElement);
         debug.BackTraceFrame mainFrame =
             trace.frames.firstWhere(
                 (debug.BackTraceFrame frame) => frame.function == callMain);
         int frame = trace.frames.indexOf(mainFrame);
         Expect.notEquals(1, frame);
         session.selectFrame(frame);
         print(trace.format());
 
         List<String> actualMessages = session.stdoutSink.takeLines();
 
         List<String> messages = new List<String>.from(program.messages);
         if (program.hasCompileTimeError) {
           print("Compile-time error expected");
           // TODO(ahe): The compile-time error message shouldn't be printed by
-          // the Fletch VM.
+          // the Dartino VM.
 
           // Find the compile-time error message in the actual output, and
           // remove all lines after it.
           int compileTimeErrorIndex = -1;
           for (int i = 0; i < actualMessages.length; i++) {
             if (actualMessages[i].startsWith("Compile error:")) {
               compileTimeErrorIndex = i;
               break;
             }
           }
@@ skipping 40 matching lines @@
   // to propagate the exitCode back to test.dart, so we can have Fail/Crash
   // outcomes of these tests.
   await session.waitForCompletion();
 
   int actualExitCode = await session.exitCode;
   // TODO(ahe): We should expect exit code 0, and instead be able to detect
   // compile-time errors directly via the session.
   int expectedExitCode = hasCompileTimeError
       ? DART_VM_EXITCODE_COMPILE_TIME_ERROR : 0;
   Expect.equals(
-      expectedExitCode, actualExitCode, "Unexpected exit code from fletch VM");
+      expectedExitCode, actualExitCode, "Unexpected exit code from dartino VM");
 }
 
 class SerializeScopeTestCase extends CompilerTestCase {
   final String source;
 
   final String scopeInfo;
 
   final Compiler compiler = null; // TODO(ahe): Provide a compiler.
 
   SerializeScopeTestCase(
@@ skipping 95 matching lines @@
       this.futures,
       this.exitCode)
       : super(vmSocket, compiler, new BytesSink(), null);
 
   // Refines type of [stdoutSink].
   BytesSink get stdoutSink => super.stdoutSink;
 
   void writeStdout(String s) {
     // Unfortunately, print will always add a newline, and the alternative is
     // to use stdout.write. However, to make it easier to debug problems in
-    // this and other fletch_tests, everything that is printed to stdout ends
+    // this and other dartino_tests, everything that is printed to stdout ends
     // up on the console of test.dart. This is good enough for testing, but DO
     // NOT COPY TO PRODUCTION CODE.
     print(s);
   }
 
   void writeStdoutLine(String s) {
     print(s);
   }
 
   /// Add [future] to this session.  All futures that can fail after calling
@@ skipping 31 matching lines @@
         sb.writeln("Problem #${++problemCount}:");
         sb.writeln(error);
         sb.writeln("");
       }
     }
     await stdoutFuture;
     List<String> stdoutLines = stdoutSink.takeLines();
     List<String> stderrLines = await stderrFuture;
     if (stdoutLines.isNotEmpty) {
       sb.writeln("Problem #${++problemCount}:");
-      sb.writeln("Unexpected stdout from fletch-vm:");
+      sb.writeln("Unexpected stdout from dartino-vm:");
       for (String line in stdoutLines) {
         sb.writeln(line);
       }
       sb.writeln("");
     }
     if (stderrLines.isNotEmpty) {
       sb.writeln("Problem #${++problemCount}:");
-      sb.writeln("Unexpected stderr from fletch-vm:");
+      sb.writeln("Unexpected stderr from dartino-vm:");
       for (String line in stderrLines) {
         sb.writeln(line);
       }
       sb.writeln("");
     }
     if (problemCount > 0) {
       throw new StateError('Test has $problemCount problem(s). Details:\n$sb');
     }
   }
 
   static Future<String> convertErrorToString(Future future) {
     return future.then((_) => null).catchError((error, stackTrace) {
       return "$error\n$stackTrace";
     });
   }
 
   static Future<TestSession> spawnVm(
       IncrementalCompiler compiler,
       {String testName}) async {
-    String vmPath = guessFletchVm(null).toFilePath();
+    String vmPath = guessDartinoVm(null).toFilePath();
 
     List<Future> futures = <Future>[];
     void recordFuture(String name, Future future) {
       if (future != null) {
         futures.add(convertErrorToString(future));
       }
     }
 
     List<String> vmOptions = <String>[
         '-Xvalidate-heaps',
     ];
 
     print("Running '$vmPath ${vmOptions.join(" ")}'");
     var environment = getProcessEnvironment(testName);
-    FletchVm fletchVm = await FletchVm.start(
+    DartinoVm dartinoVm = await DartinoVm.start(
         vmPath, arguments: vmOptions, environment: environment);
 
-    // Unlike [fletchvm.stdoutLines] and [fletchvm.stderrLines], their
+    // Unlike [dartinovm.stdoutLines] and [dartinovm.stderrLines], their
     // corresponding controller cannot produce an error.
     StreamController<String> stdoutController = new StreamController<String>();
     StreamController<String> stderrController = new StreamController<String>();
-    recordFuture("stdout", fletchVm.stdoutLines.listen((String line) {
-      print('fletch_vm_stdout: $line');
+    recordFuture("stdout", dartinoVm.stdoutLines.listen((String line) {
+      print('dartino_vm_stdout: $line');
       stdoutController.add(line);
     }).asFuture().whenComplete(stdoutController.close));
-    recordFuture("stderr", fletchVm.stderrLines.listen((String line) {
-      print('fletch_vm_stderr: $line');
+    recordFuture("stderr", dartinoVm.stderrLines.listen((String line) {
+      print('dartino_vm_stderr: $line');
       stderrController.add(line);
     }).asFuture().whenComplete(stderrController.close));
 
     Completer<int> exitCodeCompleter = new Completer<int>();
 
     // TODO(ahe): If the VM crashes on startup, this will never complete. This
     // makes this program hang forever. But the exitCode completer might
     // actually be ready to give us a crashed exit code. Exiting early with a
     // failure in case exitCode is ready before server.first or having a
     // timeout on server.first would be possible solutions.
-    var vmSocket = await fletchVm.connect();
+    var vmSocket = await dartinoVm.connect();
     recordFuture("vmSocket", vmSocket.done);
 
     TestSession session = new TestSession(
-        vmSocket, compiler, fletchVm.process,
+        vmSocket, compiler, dartinoVm.process,
         new StreamIterator(stdoutController.stream),
         stderrController.stream,
         futures, exitCodeCompleter.future);
 
-    recordFuture("exitCode", fletchVm.exitCode.then((int exitCode) {
+    recordFuture("exitCode", dartinoVm.exitCode.then((int exitCode) {
       print("VM exited with exit code: $exitCode.");
       exitCodeCompleter.complete(exitCode);
     }));
 
     return session;
   }
 
   static Map<String, String> getProcessEnvironment(String testName) {
     if (testName == null) return null;
 
@@ skipping 36 matching lines @@
   }
 }
 
 class IncrementalTestHelper {
   final Uri packageConfig;
 
   final IoInputProvider inputProvider;
 
   final IncrementalCompiler compiler;
 
-  FletchSystem system;
+  DartinoSystem system;
 
   IncrementalTestHelper.internal(
       this.packageConfig,
       this.inputProvider,
       this.compiler);
 
   factory IncrementalTestHelper(IncrementalMode incrementalMode) {
     Uri packageConfig = Uri.base.resolve('.packages');
     IoInputProvider inputProvider = new IoInputProvider(packageConfig);
     FormattingDiagnosticHandler diagnosticHandler =
         new FormattingDiagnosticHandler(inputProvider);
     IncrementalCompiler compiler = new IncrementalCompiler(
         packageConfig: packageConfig,
         inputProvider: inputProvider,
         diagnosticHandler: diagnosticHandler,
         outputProvider: new OutputProvider(),
         support: incrementalMode,
-        platform: "fletch_mobile.platform");
+        platform: "dartino_mobile.platform");
     return new IncrementalTestHelper.internal(
         packageConfig,
         inputProvider,
         compiler);
   }
 
-  Future<FletchDelta> fullCompile(ProgramResult program) async {
+  Future<DartinoDelta> fullCompile(ProgramResult program) async {
     Map<String, String> code = computeCode(program);
     inputProvider.sources.clear();
     code.forEach((String name, String code) {
       inputProvider.sources[customUriBase.resolve(name)] = code;
     });
 
     await compiler.compile(customUriBase.resolve('main.dart'), customUriBase);
-    FletchDelta delta = compiler.compiler.context.backend.computeDelta();
+    DartinoDelta delta = compiler.compiler.context.backend.computeDelta();
     system = delta.system;
     return delta;
   }
 
-  Future<FletchDelta> incrementalCompile(
+  Future<DartinoDelta> incrementalCompile(
       ProgramResult program,
       int version) async {
     Map<String, String> code = computeCode(program);
     Map<Uri, Uri> uriMap = <Uri, Uri>{};
     for (String name in code.keys) {
       Uri uri = customUriBase.resolve('$name?v$version');
       inputProvider.cachedSources[uri] = new Future.value(code[name]);
       uriMap[customUriBase.resolve(name)] = uri;
     }
-    FletchDelta delta = await compiler.compileUpdates(
+    DartinoDelta delta = await compiler.compileUpdates(
         system, uriMap, logVerbose: logger, logTime: logger);
     system = delta.system;
     return delta;
   }
 
   Map<String, String> computeCode(ProgramResult program) {
     return program.code is String
         ? <String,String>{ 'main.dart': program.code }
         : program.code;
   }
@@ skipping 40 matching lines @@
 
   Future<List<int>> readUtf8BytesFromUri(Uri uri) {
     throw "not supported";
   }
 
   static String readCachedFile(Uri uri) {
     return cachedFiles.putIfAbsent(
         uri, () => new File.fromUri(uri).readAsStringSync());
   }
 }