Rename fletch -> dartino

pkg/dartino_compiler/lib/src/dartino_compiler_implementation.dart

 // Copyright (c) 2015, the Dartino 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 fletchc.fletch_compiler_implementation;
+library dartino_compiler.dartino_compiler_implementation;
 
 import 'dart:async' show
     EventSink;
 
 import 'package:compiler/compiler_new.dart' as api;
 
 import 'package:compiler/src/apiimpl.dart' show
     CompilerImpl,
     makeDiagnosticOptions;
 
@@ skipping 17 matching lines @@
 import 'package:compiler/src/diagnostics/source_span.dart' show
     SourceSpan;
 
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart' show
     DiagnosticMessage,
     DiagnosticReporter;
 
 import 'package:compiler/src/diagnostics/spannable.dart' show
     Spannable;
 
-import 'fletch_function_builder.dart';
+import 'dartino_function_builder.dart';
 import 'debug_info.dart';
 import 'find_position_visitor.dart';
-import 'fletch_context.dart';
+import 'dartino_context.dart';
 
-import 'fletch_enqueuer.dart' show
-    FletchEnqueueTask;
+import 'dartino_enqueuer.dart' show
+    DartinoEnqueueTask;
 
-import '../fletch_system.dart';
+import '../dartino_system.dart';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/elements/elements.dart';
 
-import '../incremental/fletchc_incremental.dart' show
+import '../incremental/dartino_compiler_incremental.dart' show
     IncrementalCompiler;
 
-import 'fletch_diagnostic_reporter.dart' show
-    FletchDiagnosticReporter;
+import 'dartino_diagnostic_reporter.dart' show
+    DartinoDiagnosticReporter;
 
 const EXTRA_DART2JS_OPTIONS = const <String>[
     // TODO(ahe): This doesn't completely disable type inference. Investigate.
     '--disable-type-inference',
     '--output-type=dart',
     // We want to continue generating code in the case of errors, to support
     // incremental fixes of erroneous code.
     '--generate-code-with-compile-time-errors',
 ];
 
-const FLETCH_PATCHES = const <String, String>{
+const DARTINO_PATCHES = const <String, String>{
   "_internal": "internal/internal_patch.dart",
   "collection": "collection/collection_patch.dart",
   "convert": "convert/convert_patch.dart",
   "math": "math/math_patch.dart",
   "async": "async/async_patch.dart",
   "typed_data": "typed_data/typed_data_patch.dart",
 };
 
-const FLETCH_PLATFORM = 3;
+const DARTINO_PLATFORM = 3;
 
-DiagnosticOptions makeFletchDiagnosticOptions(
+DiagnosticOptions makeDartinoDiagnosticOptions(
     {bool suppressWarnings: false,
      bool fatalWarnings: false,
      bool suppressHints: false,
      bool terseDiagnostics: false,
      bool showPackageWarnings: true}) {
   return makeDiagnosticOptions(
       suppressWarnings: suppressWarnings,
       fatalWarnings: fatalWarnings,
       suppressHints: suppressHints,
       terseDiagnostics: terseDiagnostics,
       showPackageWarnings: true);
 }
 
-class FletchCompilerImplementation extends CompilerImpl {
-  final Uri fletchVm;
+class DartinoCompilerImplementation extends CompilerImpl {
+  final Uri dartinoVm;
 
   final Uri nativesJson;
 
   final IncrementalCompiler incrementalCompiler;
 
   Map<Uri, CompilationUnitElementX> compilationUnits;
-  FletchContext internalContext;
+  DartinoContext internalContext;
 
-  /// A reference to [../compiler.dart:FletchCompiler] used for testing.
+  /// A reference to [../compiler.dart:DartinoCompiler] used for testing.
   // TODO(ahe): Clean this up and remove this.
   var helper;
 
   @override
-  FletchEnqueueTask get enqueuer => super.enqueuer;
+  DartinoEnqueueTask get enqueuer => super.enqueuer;
 
-  FletchCompilerImplementation(
+  DartinoCompilerImplementation(
       api.CompilerInput provider,
       api.CompilerOutput outputProvider,
       api.CompilerDiagnostics handler,
       Uri libraryRoot,
       Uri packageConfig,
       this.nativesJson,
       List<String> options,
       Map<String, dynamic> environment,
-      this.fletchVm,
+      this.dartinoVm,
       this.incrementalCompiler)
       : super(
           provider, outputProvider, handler, libraryRoot, null,
           EXTRA_DART2JS_OPTIONS.toList()..addAll(options), environment,
-          packageConfig, null, FletchBackend.createInstance,
-          FletchDiagnosticReporter.createInstance,
-          makeFletchDiagnosticOptions);
+          packageConfig, null, DartinoBackend.createInstance,
+          DartinoDiagnosticReporter.createInstance,
+          makeDartinoDiagnosticOptions);
 
-  FletchContext get context {
+  DartinoContext get context {
     if (internalContext == null) {
-      internalContext = new FletchContext(this);
+      internalContext = new DartinoContext(this);
     }
     return internalContext;
   }
 
-  String fletchPatchLibraryFor(String name) {
+  String dartinoPatchLibraryFor(String name) {
     // TODO(sigurdm): Try to remove this special casing.
     if (name == "core") {
-      return platformConfigUri.path.endsWith("fletch_embedded.platform")
+      return platformConfigUri.path.endsWith("dartino_embedded.platform")
           ? "core/embedded_core_patch.dart"
           : "core/core_patch.dart";
     }
-    return FLETCH_PATCHES[name];
+    return DARTINO_PATCHES[name];
   }
 
   @override
   Uri resolvePatchUri(String dartLibraryPath) {
-    String path = fletchPatchLibraryFor(dartLibraryPath);
+    String path = dartinoPatchLibraryFor(dartLibraryPath);
     if (path == null) return null;
-    // Fletch patches are located relative to [libraryRoot].
+    // Dartino patches are located relative to [libraryRoot].
     return libraryRoot.resolve(path);
   }
 
   CompilationUnitElementX compilationUnitForUri(Uri uri) {
     if (compilationUnits == null) {
       compilationUnits = <Uri, CompilationUnitElementX>{};
       libraryLoader.libraries.forEach((LibraryElementX library) {
         for (CompilationUnitElementX unit in library.compilationUnits) {
           compilationUnits[unit.script.resourceUri] = unit;
         }
       });
     }
     return compilationUnits[uri];
   }
 
   DebugInfo debugInfoForPosition(
       Uri file,
       int position,
-      FletchSystem currentSystem) {
+      DartinoSystem currentSystem) {
     Uri uri = Uri.base.resolveUri(file);
     CompilationUnitElementX unit = compilationUnitForUri(uri);
     if (unit == null) return null;
     FindPositionVisitor visitor = new FindPositionVisitor(position, unit);
     unit.accept(visitor, null);
-    FletchFunctionBuilder builder =
+    DartinoFunctionBuilder builder =
         context.backend.systemBuilder.lookupFunctionBuilderByElement(
             visitor.element);
     if (builder == null) return null;
     // TODO(ajohnsen): We need a mapping from element to functionId, that can
-    // be looked up in the current fletch system.
-    FletchFunction function = builder.finalizeFunction(context, []);
+    // be looked up in the current dartino system.
+    DartinoFunction function = builder.finalizeFunction(context, []);
     return context.backend.createDebugInfo(function, currentSystem);
   }
 
   int positionInFileFromPattern(Uri file, int line, String pattern) {
     Uri uri = Uri.base.resolveUri(file);
     SourceFile sourceFile = getSourceFile(provider, uri);
     if (sourceFile == null) return null;
     List<int> lineStarts = sourceFile.lineStarts;
     if (line >= lineStarts.length) return null;
     int begin = lineStarts[line];
@@ skipping 30 matching lines @@
       MessageTemplate template = MessageTemplate.TEMPLATES[MessageKind.GENERIC];
       SourceSpan span = reporter.spanFromSpannable(node);
       Message message = template.message({'text': messageText});
       reportDiagnostic(new DiagnosticMessage(span, node, message),
           [], api.Diagnostic.HINT);
     }
   }
 
   @override
   void compileLoadedLibraries() {
-    // TODO(ahe): Ensure fletchSystemLibrary is not null
+    // TODO(ahe): Ensure dartinoSystemLibrary is not null
     // (also when mainApp is null).
     if (mainApp == null) {
       return;
     }
     super.compileLoadedLibraries();
   }
 }
 
 /// Output provider which collects output in [output].
 class OutputProvider implements CompilerOutput {
@@ skipping 33 matching lines @@
   }
 }
 
 SourceFile getSourceFile(api.CompilerInput provider, Uri uri) {
   if (provider is SourceFileProvider) {
     return provider.getSourceFile(uri);
   } else {
     return null;
   }
 }