Rename fletch -> dartino

pkg/dartino_compiler/lib/src/dartino_enqueuer.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_enqueuer;
+library dartino_compiler.dartino_enqueuer;
 
 import 'dart:collection' show
     Queue;
 
 import 'package:compiler/src/common/tasks.dart' show
   CompilerTask;
 
 import 'package:compiler/src/universe/world_impact.dart' show
     WorldImpact;
 
@@ skipping 33 matching lines @@
     LocalFunctionElement,
     Name,
     TypedElement;
 
 import 'package:compiler/src/resolution/tree_elements.dart' show
     TreeElements;
 
 import 'package:compiler/src/util/util.dart' show
     Hashing;
 
-import 'fletch_compiler_implementation.dart' show
-    FletchCompilerImplementation;
+import 'dartino_compiler_implementation.dart' show
+    DartinoCompilerImplementation;
 
 import 'dynamic_call_enqueuer.dart' show
     Closurization,
     DynamicCallEnqueuer,
     UsageRecorder;
 
-import 'fletch_registry.dart' show
+import 'dartino_registry.dart' show
     ClosureKind,
-    FletchRegistry,
-    FletchRegistry;
+    DartinoRegistry,
+    DartinoRegistry;
 
 import 'dart:developer';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 
 import 'package:compiler/src/universe/use.dart' show
     DynamicUse,
     StaticUse;
 
 import 'package:compiler/src/universe/use.dart';
 import 'package:compiler/src/common/work.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/enqueue.dart';
 
 part 'enqueuer_mixin.dart';
 
 /// True if enqueuing of system libraries should be reported in verbose mode.
 const bool logSystemLibraries =
-    const bool.fromEnvironment("fletchc.logSystemLibraries");
+    const bool.fromEnvironment("dartino_compiler.logSystemLibraries");
 
 /// Returns true if enqueuing of [element] should be reported in verbose
 /// mode. See [logSystemLibraries].
 bool shouldReportEnqueuingOfElement(Compiler compiler, Element element) {
   if (logSystemLibraries) return true;
   return compiler.inUserCode(element);
 }
 
-/// Custom enqueuer for Fletch.
-class FletchEnqueueTask extends CompilerTask implements EnqueueTask {
+/// Custom enqueuer for Dartino.
+class DartinoEnqueueTask extends CompilerTask implements EnqueueTask {
   final ResolutionEnqueuer resolution;
 
-  final FletchEnqueuer codegen;
+  final DartinoEnqueuer codegen;
 
-  FletchEnqueueTask(FletchCompilerImplementation compiler)
+  DartinoEnqueueTask(DartinoCompilerImplementation compiler)
     : resolution = new ResolutionEnqueuer(
           compiler, compiler.backend.createItemCompilationContext,
           compiler.analyzeOnly && compiler.analyzeMain
               ? const EnqueuerStrategy() : const TreeShakingEnqueuerStrategy()),
-      codegen = new FletchEnqueuer(
+      codegen = new DartinoEnqueuer(
           compiler, compiler.backend.createItemCompilationContext),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
 
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 
-  String get name => 'Fletch enqueue';
+  String get name => 'Dartino enqueue';
 
   void forgetElement(Element element) {
     resolution.forgetElement(element);
     codegen.forgetElement(element);
   }
 }
 
-class FletchEnqueuer extends EnqueuerMixin
+class DartinoEnqueuer extends EnqueuerMixin
     implements CodegenEnqueuer, UsageRecorder {
   final ItemCompilationContextCreator itemCompilationContextCreator;
 
-  final FletchCompilerImplementation compiler;
+  final DartinoCompilerImplementation compiler;
 
   bool queueIsClosed = false;
 
   bool hasEnqueuedReflectiveElements = false;
 
   bool hasEnqueuedReflectiveStaticFields = false;
 
   EnqueueTask task;
 
   // TODO(ahe): Get rid of this?
   var nativeEnqueuer;
 
   final Universe universe = new Universe(const TypeMaskStrategy());
 
   final Set<ElementUsage> _enqueuedUsages = new Set<ElementUsage>();
   final Map<Element, List<ElementUsage>> _enqueuedUsagesByElement =
       <Element, List<ElementUsage>>{};
 
   final Queue<ElementUsage> _pendingEnqueuedUsages =
       new Queue<ElementUsage>();
 
   final Set<TypeTest> _typeTests = new Set<TypeTest>();
 
   final Queue<TypeTest> _pendingTypeTests = new Queue<TypeTest>();
 
   final DynamicCallEnqueuer dynamicCallEnqueuer;
 
-  FletchEnqueuer(
-      FletchCompilerImplementation compiler,
+  DartinoEnqueuer(
+      DartinoCompilerImplementation compiler,
       this.itemCompilationContextCreator)
       : compiler = compiler,
         dynamicCallEnqueuer = new DynamicCallEnqueuer(compiler);
 
   bool get queueIsEmpty {
     return _pendingEnqueuedUsages.isEmpty && _pendingTypeTests.isEmpty;
   }
 
   bool get isResolutionQueue => false;
 
@@ skipping 29 matching lines @@
   }
 
   void processQueue() {
     do {
       do {
         while (!queueIsEmpty) {
           if (!_pendingEnqueuedUsages.isEmpty) {
             ElementUsage usage = _pendingEnqueuedUsages.removeFirst();
             AstElement element = usage.element;
             TreeElements treeElements = element.resolvedAst.elements;
-            FletchRegistry registry = new FletchRegistry(compiler);
+            DartinoRegistry registry = new DartinoRegistry(compiler);
             Selector selector = usage.selector;
             if (usage.closureKind != null) {
               compiler.context.backend.compileClosurizationUsage(
                   element, selector, treeElements, registry, usage.closureKind);
             } else if (selector != null) {
               compiler.context.backend.compileElementUsage(
                   element, selector, treeElements, registry);
             } else {
               compiler.context.backend.compileElement(
                   element, treeElements, registry);
@@ skipping 110 matching lines @@
 
   TypeTest(ClassElement element, InterfaceType type)
       : element = element,
         type = type,
         hashCode = Hashing.mixHashCodeBits(element.hashCode, type.hashCode);
 
   bool operator ==(other) {
     return other is TypeTest && element == other.element && type == other.type;
   }
 }