Rename fletch -> dartino

pkg/dartino_compiler/lib/incremental/dartino_reuser.dart

Index: pkg/dartino_compiler/lib/incremental/dartino_reuser.dart
diff --git a/pkg/fletchc/lib/incremental/fletch_reuser.dart b/pkg/dartino_compiler/lib/incremental/dartino_reuser.dart
similarity index 74%
rename from pkg/fletchc/lib/incremental/fletch_reuser.dart
rename to pkg/dartino_compiler/lib/incremental/dartino_reuser.dart
index 08ef59d47f49b33d6b3745f0a1912bd043800751..aa7f7dff6e3e4a9054fcd2675fba9ef56b2cc3a9 100644
--- a/pkg/fletchc/lib/incremental/fletch_reuser.dart
+++ b/pkg/dartino_compiler/lib/incremental/dartino_reuser.dart
@@ -2,7 +2,7 @@
 // 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_incremental.fletch_reuser;
+library dartino_compiler_incremental.dartino_reuser;
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
@@ -37,29 +37,29 @@ import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
 import '../incremental_backend.dart' show
-    IncrementalFletchBackend;
+    IncrementalDartinoBackend;
 
-import '../src/fletch_class_builder.dart' show
-    FletchClassBuilder;
+import '../src/dartino_class_builder.dart' show
+    DartinoClassBuilder;
 
-import '../src/fletch_context.dart' show
-    FletchContext;
+import '../src/dartino_context.dart' show
+    DartinoContext;
 
-import '../src/fletch_compiler_implementation.dart' show
-    FletchCompilerImplementation;
+import '../src/dartino_compiler_implementation.dart' show
+    DartinoCompilerImplementation;
 
-import '../src/fletch_function_builder.dart' show
-    FletchFunctionBuilder;
+import '../src/dartino_function_builder.dart' show
+    DartinoFunctionBuilder;
 
 import '../vm_commands.dart' show
     PrepareForChanges,
     VmCommand;
 
-import '../fletch_system.dart' show
-    FletchDelta,
-    FletchSystem;
+import '../dartino_system.dart' show
+    DartinoDelta,
+    DartinoSystem;
 
-import 'fletchc_incremental.dart' show
+import 'dartino_compiler_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalCompiler;
 
@@ -127,21 +127,21 @@ class IncrementalCompilerContext extends _IncrementalCompilerContext
   }
 }
 
-class FletchReuser extends Reuser with FletchFeatures {
+class DartinoReuser extends Reuser with DartinoFeatures {
   final IncrementalCompilerContext _context;
 
-  FletchReuser(
-      FletchCompilerImplementation compiler,
+  DartinoReuser(
+      DartinoCompilerImplementation compiler,
       api.CompilerInputProvider inputProvider,
       Logger logTime,
       Logger logVerbose,
       this._context)
       : super(compiler, inputProvider, logTime, logVerbose);
 
-  FletchDelta computeUpdateFletch(FletchSystem currentSystem) {
+  DartinoDelta computeUpdateDartino(DartinoSystem currentSystem) {
     // TODO(ahe): Remove this when we support adding static fields.
     Set<Element> existingStaticFields =
-        new Set<Element>.from(fletchContext.staticIndices.keys);
+        new Set<Element>.from(dartinoContext.staticIndices.keys);
 
     backend.newSystemBuilder(currentSystem);
 
@@ -173,7 +173,7 @@ class FletchReuser extends Reuser with FletchFeatures {
 
     // TODO(ahe): Clean this up. Don't call this method in analyze-only mode.
     if (compiler.analyzeOnly) {
-      return new FletchDelta(currentSystem, currentSystem, <VmCommand>[]);
+      return new DartinoDelta(currentSystem, currentSystem, <VmCommand>[]);
     }
 
     for (AstElement element in updatedElements) {
@@ -191,7 +191,7 @@ class FletchReuser extends Reuser with FletchFeatures {
 
     // TODO(ahe): Remove this when we support adding static fields.
     Set<Element> newStaticFields =
-        new Set<Element>.from(fletchContext.staticIndices.keys).difference(
+        new Set<Element>.from(dartinoContext.staticIndices.keys).difference(
             existingStaticFields);
     if (newStaticFields.isNotEmpty) {
       throw new IncrementalCompilationFailed(
@@ -199,55 +199,55 @@ class FletchReuser extends Reuser with FletchFeatures {
     }
 
     List<VmCommand> commands = <VmCommand>[const PrepareForChanges()];
-    FletchSystem system =
-        backend.systemBuilder.computeSystem(fletchContext, commands);
-    return new FletchDelta(system, currentSystem, commands);
+    DartinoSystem system =
+        backend.systemBuilder.computeSystem(dartinoContext, commands);
+    return new DartinoDelta(system, currentSystem, commands);
   }
 
   void addClassUpdate(
       Compiler compiler,
       PartialClassElement before,
       PartialClassElement after) {
-    updates.add(new FletchClassUpdate(compiler, before, after));
+    updates.add(new DartinoClassUpdate(compiler, before, after));
   }
 
   void addAddedFunctionUpdate(
       Compiler compiler,
       PartialFunctionElement element,
       /* ScopeContainerElement */ container) {
-    updates.add(new FletchAddedFunctionUpdate(compiler, element, container));
+    updates.add(new DartinoAddedFunctionUpdate(compiler, element, container));
   }
 
   void addRemovedFunctionUpdate(
       Compiler compiler,
       PartialFunctionElement element) {
-    updates.add(new FletchRemovedFunctionUpdate(compiler, element));
+    updates.add(new DartinoRemovedFunctionUpdate(compiler, element));
   }
 
   void addRemovedFieldUpdate(
       Compiler compiler,
       FieldElementX element) {
-    updates.add(new FletchRemovedFieldUpdate(compiler, element));
+    updates.add(new DartinoRemovedFieldUpdate(compiler, element));
   }
 
   void addRemovedClassUpdate(
       Compiler compiler,
       PartialClassElement element) {
-    updates.add(new FletchRemovedClassUpdate(compiler, element));
+    updates.add(new DartinoRemovedClassUpdate(compiler, element));
   }
 
   void addAddedFieldUpdate(
       Compiler compiler,
       FieldElementX element,
       /* ScopeContainerElement */ container) {
-    updates.add(new FletchAddedFieldUpdate(compiler, element, container));
+    updates.add(new DartinoAddedFieldUpdate(compiler, element, container));
   }
 
   void addAddedClassUpdate(
       Compiler compiler,
       PartialClassElement element,
       LibraryElementX library) {
-    updates.add(new FletchAddedClassUpdate(compiler, element, library));
+    updates.add(new DartinoAddedClassUpdate(compiler, element, library));
   }
 
   static void forEachField(ClassElement c, void action(FieldElement field)) {
@@ -312,70 +312,70 @@ class FletchReuser extends Reuser with FletchFeatures {
   }
 }
 
-class FletchRemovedFunctionUpdate extends RemovedFunctionUpdate
-    with FletchFeatures {
-  FletchRemovedFunctionUpdate(Compiler compiler, PartialFunctionElement element)
+class DartinoRemovedFunctionUpdate extends RemovedFunctionUpdate
+    with DartinoFeatures {
+  DartinoRemovedFunctionUpdate(Compiler compiler, PartialFunctionElement element)
       : super(compiler, element);
 }
 
-class FletchRemovedClassUpdate extends RemovedClassUpdate with FletchFeatures {
-  FletchRemovedClassUpdate(Compiler compiler, PartialClassElement element)
+class DartinoRemovedClassUpdate extends RemovedClassUpdate with DartinoFeatures {
+  DartinoRemovedClassUpdate(Compiler compiler, PartialClassElement element)
       : super(compiler, element);
 }
 
-class FletchRemovedFieldUpdate extends RemovedFieldUpdate with FletchFeatures {
+class DartinoRemovedFieldUpdate extends RemovedFieldUpdate with DartinoFeatures {
   // TODO(ahe): Remove?
-  FletchClassBuilder beforeFletchClassBuilder;
+  DartinoClassBuilder beforeDartinoClassBuilder;
 
-  FletchRemovedFieldUpdate(Compiler compiler, FieldElementX element)
+  DartinoRemovedFieldUpdate(Compiler compiler, FieldElementX element)
       : super(compiler, element);
 }
 
-class FletchAddedFunctionUpdate extends AddedFunctionUpdate
-    with FletchFeatures {
-  FletchAddedFunctionUpdate(
+class DartinoAddedFunctionUpdate extends AddedFunctionUpdate
+    with DartinoFeatures {
+  DartinoAddedFunctionUpdate(
       Compiler compiler,
       PartialFunctionElement element,
       /* ScopeContainerElement */ container)
       : super(compiler, element, container);
 }
 
-class FletchAddedClassUpdate extends AddedClassUpdate with FletchFeatures {
-  FletchAddedClassUpdate(
+class DartinoAddedClassUpdate extends AddedClassUpdate with DartinoFeatures {
+  DartinoAddedClassUpdate(
       Compiler compiler,
       PartialClassElement element,
       LibraryElementX library)
       : super(compiler, element, library);
 }
 
-class FletchAddedFieldUpdate extends AddedFieldUpdate with FletchFeatures {
-  FletchAddedFieldUpdate(
+class DartinoAddedFieldUpdate extends AddedFieldUpdate with DartinoFeatures {
+  DartinoAddedFieldUpdate(
       Compiler compiler,
       FieldElementX element,
       /* ScopeContainerElement */ container)
       : super(compiler, element, container);
 }
 
-class FletchClassUpdate extends ClassUpdate with FletchFeatures {
-  FletchClassUpdate(
+class DartinoClassUpdate extends ClassUpdate with DartinoFeatures {
+  DartinoClassUpdate(
       Compiler compiler,
       PartialClassElement before,
       PartialClassElement after)
       : super(compiler, before, after);
 }
 
-abstract class FletchFeatures {
-  FletchCompilerImplementation get compiler;
+abstract class DartinoFeatures {
+  DartinoCompilerImplementation get compiler;
 
-  IncrementalFletchBackend get backend {
-    return compiler.backend as IncrementalFletchBackend;
+  IncrementalDartinoBackend get backend {
+    return compiler.backend as IncrementalDartinoBackend;
   }
 
   EnqueueTask get enqueuer => compiler.enqueuer;
 
-  FletchContext get fletchContext => compiler.context;
+  DartinoContext get dartinoContext => compiler.context;
 
-  FletchFunctionBuilder lookupFletchFunctionBuilder(FunctionElement function) {
+  DartinoFunctionBuilder lookupDartinoFunctionBuilder(FunctionElement function) {
     return backend.systemBuilder.lookupFunctionBuilderByElement(function);
   }
 }