Rename fletch -> dartino

pkg/dartino_compiler/lib/incremental/dartino_reuser.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_incremental.fletch_reuser;
+library dartino_compiler_incremental.dartino_reuser;
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
     Diagnostic;
 
 import 'package:compiler/compiler.dart' as api;
 
 import 'package:compiler/src/compiler.dart' show
     Compiler;
 
@@ skipping 14 matching lines @@
 
 import 'package:compiler/src/elements/modelx.dart' show
     ClassElementX,
     FieldElementX,
     LibraryElementX;
 
 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;
 
 import 'reuser.dart' show
     AddedClassUpdate,
     AddedFieldUpdate,
     AddedFunctionUpdate,
     ClassUpdate,
     Logger,
     RemovedClassUpdate,
@@ skipping 47 matching lines @@
     if (kind == Diagnostic.WARNING) {
       warningCount++;
     }
     if (kind == Diagnostic.HINT) {
       hintCount++;
     }
     diagnostics.report(code, uri, begin, end, text, kind);
   }
 }
 
-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);
 
     List<Element> updatedElements = applyUpdates();
 
     if (compiler.progress != null) {
       compiler.progress.reset();
     }
 
     for (Element element in updatedElements) {
@@ skipping 11 matching lines @@
         // already instantiated.
         enqueuer.codegen.registerInstantiatedType(cls.rawType);
       }
     }
     compiler.processQueue(enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
     // 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) {
       if (element.node.isErroneous) {
         throw new IncrementalCompilationFailed(
             "Unable to incrementally compile $element with syntax error");
       }
       if (element.isField) {
         backend.newElement(element);
       } else if (!element.isClass) {
         enqueuer.codegen.addToWorkList(element);
       }
     }
     compiler.processQueue(enqueuer.codegen, null);
 
     // 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(
           "Unable to add static fields:\n  ${newStaticFields.join(',\n  ')}");
     }
 
     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)) {
     List classes = [];
     while (c != null) {
       if (!c.isResolved) {
         throw new IncrementalCompilationFailed("Class not resolved: $c");
       }
       classes.add(c);
       c = c.superclass;
@@ skipping 44 matching lines @@
 
   bool allowAddedElement(PartialElement element) {
     if (!_context.incrementalCompiler.isExperimentalModeEnabled) {
       return cannotReuse(
           element, "Adding elements requires 'experimental' mode");
     }
     return true;
   }
 }
 
-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);
   }
 }