Rename fletch -> dartino

pkg/dartino_compiler/lib/src/dartino_context.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_context;
+library dartino_compiler.dartino_context;
 
 import 'package:compiler/src/tree/tree.dart' show
     Node;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     Element,
     FieldElement,
     FunctionElement,
     FunctionSignature,
     LibraryElement,
     ParameterElement,
     Name;
 
 import 'package:compiler/src/resolution/tree_elements.dart' show
     TreeElements;
 
 import 'package:compiler/src/universe/selector.dart' show
     Selector;
 
 import 'package:compiler/src/constants/expressions.dart' show
     ConstantExpression;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     FunctionConstantValue;
 
-import 'fletch_compiler_implementation.dart' show
-    FletchCompilerImplementation;
+import 'dartino_compiler_implementation.dart' show
+    DartinoCompilerImplementation;
 
-export 'fletch_compiler_implementation.dart' show
-    FletchCompilerImplementation;
+export 'dartino_compiler_implementation.dart' show
+    DartinoCompilerImplementation;
 
-import 'fletch_backend.dart' show
-    FletchBackend;
+import 'dartino_backend.dart' show
+    DartinoBackend;
 
-export 'fletch_backend.dart' show
-    FletchBackend;
+export 'dartino_backend.dart' show
+    DartinoBackend;
 
 export 'bytecode_assembler.dart' show
     BytecodeAssembler,
     BytecodeLabel;
 
-import 'fletch_native_descriptor.dart' show
-    FletchNativeDescriptor;
+import 'dartino_native_descriptor.dart' show
+    DartinoNativeDescriptor;
 
-import 'fletch_selector.dart' show
-    FletchSelector,
+import 'dartino_selector.dart' show
+    DartinoSelector,
     SelectorKind;
 
-export 'fletch_native_descriptor.dart' show
-    FletchNativeDescriptor;
+export 'dartino_native_descriptor.dart' show
+    DartinoNativeDescriptor;
 
-import 'fletch_registry.dart' show
-    FletchRegistry;
+import 'dartino_registry.dart' show
+    DartinoRegistry;
 
-class FletchContext {
-  final FletchCompilerImplementation compiler;
+class DartinoContext {
+  final DartinoCompilerImplementation compiler;
 
-  Map<String, FletchNativeDescriptor> nativeDescriptors;
+  Map<String, DartinoNativeDescriptor> nativeDescriptors;
 
   Set<String> names = new Set<String>();
 
   Map<FieldElement, int> staticIndices = <FieldElement, int>{};
 
   Map<LibraryElement, String> libraryTag = <LibraryElement, String>{};
   List<String> symbols = <String>[];
   Map<String, int> symbolIds = <String, int>{};
   Map<Name, String> nameToSymbol = <Name, String>{};
   Map<Selector, String> selectorToSymbol = <Selector, String>{};
 
-  FletchContext(this.compiler);
+  DartinoContext(this.compiler);
 
-  FletchBackend get backend => compiler.backend;
+  DartinoBackend get backend => compiler.backend;
 
   bool get enableBigint {
-    String enableBigintConstant = compiler.environment['fletch.enable-bigint'];
+    String enableBigintConstant = compiler.environment['dartino.enable-bigint'];
     return enableBigintConstant != "false";
   }
 
   void setNames(Map<String, String> names) {
     // Generate symbols of the values.
     for (String name in names.values) {
       this.names.add(name);
       getSymbolId(name);
     }
   }
@@ skipping 62 matching lines @@
       symbols.add(symbol);
       backend.systemBuilder.registerSymbol(symbol, id);
       return id;
     });
   }
 
   void forEachStatic(f(FieldElement element, int index)) {
     staticIndices.forEach(f);
   }
 
-  int toFletchSelector(Selector selector) {
+  int toDartinoSelector(Selector selector) {
     String symbol = getSymbolFromSelector(selector);
     int id = getSymbolId(symbol);
-    SelectorKind kind = getFletchSelectorKind(selector);
-    return FletchSelector.encode(id, kind, selector.argumentCount);
+    SelectorKind kind = getDartinoSelectorKind(selector);
+    return DartinoSelector.encode(id, kind, selector.argumentCount);
   }
 
-  int toFletchIsSelector(ClassElement classElement, [int arity]) {
+  int toDartinoIsSelector(ClassElement classElement, [int arity]) {
     LibraryElement library = classElement.library;
     StringBuffer buffer = new StringBuffer();
     buffer.write("?is?");
     buffer.write(classElement.name);
     buffer.write("?");
     buffer.write(getLibraryTag(library));
     int id = getSymbolId(buffer.toString());
-    if (arity == null) return FletchSelector.encodeGetter(id);
-    return FletchSelector.encodeMethod(id, arity);
+    if (arity == null) return DartinoSelector.encodeGetter(id);
+    return DartinoSelector.encodeMethod(id, arity);
   }
 
-  int toFletchTearoffIsSelector(
+  int toDartinoTearoffIsSelector(
       String functionName,
       ClassElement classElement) {
     LibraryElement library = classElement.library;
     StringBuffer buffer = new StringBuffer();
     buffer.write("?is?");
     buffer.write(functionName);
     buffer.write("?");
     buffer.write(classElement.name);
     buffer.write("?");
     buffer.write(getLibraryTag(library));
     int id = getSymbolId(buffer.toString());
-    return FletchSelector.encodeMethod(id, 0);
+    return DartinoSelector.encodeMethod(id, 0);
   }
 
-  SelectorKind getFletchSelectorKind(Selector selector) {
+  SelectorKind getDartinoSelectorKind(Selector selector) {
     if (selector.isGetter) return SelectorKind.Getter;
     if (selector.isSetter) return SelectorKind.Setter;
     return SelectorKind.Method;
   }
 
   void registerConstructedConstantValue(ConstructedConstantValue value) {
     ClassElement classElement = value.type.element;
     backend.registerClassElement(classElement);
     // TODO(ahe): This should not be required. Also, instantiate type,
     // not class.
-    FletchRegistry registry = new FletchRegistry(compiler);
+    DartinoRegistry registry = new DartinoRegistry(compiler);
     registry.registerInstantiatedClass(classElement);
   }
 
   void registerFunctionConstantValue(FunctionConstantValue value) {
     backend.markFunctionConstantAsUsed(value);
   }
 
-  // TODO(zarah): Remove this and use the FletchSystemBuilder
+  // TODO(zarah): Remove this and use the DartinoSystemBuilder
   void markConstantUsed(ConstantValue constant) {
     backend.systemBuilder.registerConstant(constant, this);
   }
 
-  // TODO(zarah): Remove this and use the FletchSystemBuilder
+  // TODO(zarah): Remove this and use the DartinoSystemBuilder
   int lookupConstantIdByValue(ConstantValue value) =>
       backend.systemBuilder.lookupConstantIdByValue(value);
 
   /// If [isConst] is true, a compile-time error is reported.
   ConstantExpression compileConstant(
       Node node,
       TreeElements elements,
       {bool isConst}) {
     ConstantExpression expression =
         inspectConstant(node, elements, isConst: isConst);
@@ skipping 12 matching lines @@
     ConstantExpression expression =
         compiler.resolver.constantCompiler.compileNode(
             node, elements, enforceConst: isConst);
     return expression;
   }
 
   ConstantValue getConstantValue(ConstantExpression expression) {
     return compiler.constants.getConstantValue(expression);
   }
 }