Rename fletch -> dartino

pkg/dartino_compiler/lib/incremental/dartino_compiler_incremental.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_incremental;
+library dartino_compiler_incremental;
 
 import 'dart:async' show
     EventSink,
     Future;
 
 import 'dart:developer' show
     UserTag;
 
 import 'package:compiler/src/apiimpl.dart' show
     CompilerImpl;
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
     CompilerInput,
     CompilerOutput,
     Diagnostic;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     ConstructorElement,
     Element,
     FunctionElement,
     LibraryElement;
 
 import 'package:compiler/src/library_loader.dart' show
     ReuseLibrariesFunction;
 
-import 'fletch_reuser.dart' show
+import 'dartino_reuser.dart' show
     IncrementalCompilerContext,
-    FletchReuser,
+    DartinoReuser,
     Logger;
 
-import '../fletch_compiler.dart' show
-    FletchCompiler;
+import '../dartino_compiler.dart' show
+    DartinoCompiler;
 
 import '../src/debug_info.dart' show
     DebugInfo;
 
 import '../src/class_debug_info.dart' show
     ClassDebugInfo;
 
-import '../src/fletch_selector.dart' show
-    FletchSelector;
+import '../src/dartino_selector.dart' show
+    DartinoSelector;
 
-import '../src/fletch_compiler_implementation.dart' show
-    FletchCompilerImplementation,
+import '../src/dartino_compiler_implementation.dart' show
+    DartinoCompilerImplementation,
     OutputProvider;
 
-import '../fletch_system.dart';
+import '../dartino_system.dart';
 
-import '../src/fletch_backend.dart' show
-    FletchBackend;
+import '../src/dartino_backend.dart' show
+    DartinoBackend;
 
 import '../src/hub/exit_codes.dart' as exit_codes;
 
 import 'package:compiler/src/source_file_provider.dart' show
     SourceFileProvider;
 
 import 'package:compiler/src/tokens/token.dart' show
     Token;
 
 import 'package:compiler/src/diagnostics/source_span.dart' show
@@ skipping 21 matching lines @@
   /// All incremental features are turned on even if we know that we don't
   /// always generate correct code. Initially, this covers features such as
   /// schema changes.
   experimental,
 }
 
 class IncrementalCompiler {
   final Uri libraryRoot;
   final Uri nativesJson;
   final Uri packageConfig;
-  final Uri fletchVm;
+  final Uri dartinoVm;
   final CompilerInput inputProvider;
   final List<String> options;
   final CompilerOutput outputProvider;
   final Map<String, dynamic> environment;
   final IncrementalCompilerContext _context;
   final IncrementalMode support;
   final String platform;
   final Map<Uri, Uri> _updatedFiles = new Map<Uri, Uri>();
 
-  FletchCompilerImplementation _compiler;
+  DartinoCompilerImplementation _compiler;
 
   IncrementalCompiler(
       {this.libraryRoot,
        this.nativesJson,
        this.packageConfig,
-       this.fletchVm,
+       this.dartinoVm,
        this.inputProvider,
        CompilerDiagnostics diagnosticHandler,
        this.options,
        this.outputProvider,
        this.environment,
        this.support: IncrementalMode.none,
        this.platform})
       : _context = new IncrementalCompilerContext(diagnosticHandler) {
     // if (libraryRoot == null) {
     //   throw new ArgumentError('libraryRoot is null.');
@@ skipping 17 matching lines @@
     return support == IncrementalMode.production ||
         support == IncrementalMode.experimental;
   }
 
   bool get isExperimentalModeEnabled {
     return support == IncrementalMode.experimental;
   }
 
   LibraryElement get mainApp => _compiler.mainApp;
 
-  FletchCompilerImplementation get compiler => _compiler;
+  DartinoCompilerImplementation get compiler => _compiler;
 
   /// Perform a full compile of [script]. This will reset the incremental
   /// compiler.
   ///
   /// Error messages will be reported relative to [base].
   ///
   /// Notice: a full compile means not incremental. The part of the program
   /// that is compiled is determined by tree shaking.
   Future<bool> compile(Uri script, Uri base) {
     _compiler = null;
@@ skipping 37 matching lines @@
         ? <String> [] : new List<String>.from(this.options);
     options.addAll(INCREMENTAL_OPTIONS);
     if (analyzeOnly) {
       options.add("--analyze-only");
     }
     return reuseCompiler(
         cachedCompiler: _compiler,
         libraryRoot: libraryRoot,
         packageConfig: packageConfig,
         nativesJson: nativesJson,
-        fletchVm: fletchVm,
+        dartinoVm: dartinoVm,
         inputProvider: inputProvider,
         diagnosticHandler: _context,
         options: options,
         outputProvider: outputProvider,
         environment: environment,
         reuseLibraries: reuseLibraries,
         platform: platform,
         base: base,
         incrementalCompiler: this);
   }
 
   void _checkCompilationFailed() {
     if (!isExperimentalModeEnabled && _compiler.compilationFailed) {
       throw new IncrementalCompilationFailed(
           "Unable to reuse compiler due to compile-time errors");
     }
   }
 
   /// Perform an incremental compilation of [updatedFiles]. [compile] must have
   /// been called once before calling this method.
   ///
   /// Error messages will be reported relative to [base], if [base] is not
   /// provided the previous set [base] will be used.
-  Future<FletchDelta> compileUpdates(
-      FletchSystem currentSystem,
+  Future<DartinoDelta> compileUpdates(
+      DartinoSystem currentSystem,
       Map<Uri, Uri> updatedFiles,
       {Logger logTime,
        Logger logVerbose,
        Uri base}) {
     _checkCompilationFailed();
     if (logTime == null) {
       logTime = (_) {};
     }
     if (logVerbose == null) {
       logVerbose = (_) {};
     }
     updatedFiles.forEach((Uri from, Uri to) {
       _updatedFiles[from] = to;
     });
     Future mappingInputProvider(Uri uri) {
       Uri updatedFile = _updatedFiles[uri];
       return inputProvider.readFromUri(updatedFile == null ? uri : updatedFile);
     }
-    FletchReuser reuser = new FletchReuser(
+    DartinoReuser reuser = new DartinoReuser(
         _compiler,
         mappingInputProvider,
         logTime,
         logVerbose,
         _context);
     _context.registerUriWithUpdates(updatedFiles.keys);
     return _reuseCompiler(reuser.reuseLibraries, base: base).then(
         (CompilerImpl compiler) async {
           _compiler = compiler;
-          FletchDelta delta = await reuser.computeUpdateFletch(currentSystem);
+          DartinoDelta delta = await reuser.computeUpdateDartino(currentSystem);
           _checkCompilationFailed();
           return delta;
         });
   }
 
-  FletchDelta computeInitialDelta() {
-    FletchBackend backend = _compiler.backend;
+  DartinoDelta computeInitialDelta() {
+    DartinoBackend backend = _compiler.backend;
     return backend.computeDelta();
   }
 
-  String lookupFunctionName(FletchFunction function) {
+  String lookupFunctionName(DartinoFunction function) {
     if (function.isParameterStub) return "<parameter stub>";
     Element element = function.element;
     if (element == null) return function.name;
     if (element.isConstructor) {
       ConstructorElement constructor = element;
       ClassElement enclosing = constructor.enclosingClass;
       String name = (constructor.name == null || constructor.name.length == 0)
           ? ''
           : '.${constructor.name}';
       String postfix = function.isInitializerList ? ' initializer' : '';
       return '${enclosing.name}$name$postfix';
     }
 
     ClassElement enclosing = element.enclosingClass;
     if (enclosing == null) return function.name;
     return '${enclosing.name}.${function.name}';
   }
 
-  ClassDebugInfo createClassDebugInfo(FletchClass klass) {
+  ClassDebugInfo createClassDebugInfo(DartinoClass klass) {
     return _compiler.context.backend.createClassDebugInfo(klass);
   }
 
   String lookupFunctionNameBySelector(int selector) {
-    int id = FletchSelector.decodeId(selector);
+    int id = DartinoSelector.decodeId(selector);
     return _compiler.context.symbols[id];
   }
 
   DebugInfo createDebugInfo(
-      FletchFunction function,
-      FletchSystem currentSystem) {
+      DartinoFunction function,
+      DartinoSystem currentSystem) {
     return _compiler.context.backend.createDebugInfo(function, currentSystem);
   }
 
   DebugInfo debugInfoForPosition(
       Uri file,
       int position,
-      FletchSystem currentSystem) {
+      DartinoSystem currentSystem) {
     return _compiler.debugInfoForPosition(file, position, currentSystem);
   }
 
   int positionInFileFromPattern(Uri file, int line, String pattern) {
     return _compiler.positionInFileFromPattern(file, line, pattern);
   }
 
   int positionInFile(Uri file, int line, int column) {
     return _compiler.positionInFile(file, line, column);
   }
@@ skipping 45 matching lines @@
 
     case "production":
         return IncrementalMode.production;
 
     case "experimental":
       return IncrementalMode.experimental;
 
   }
   return null;
 }