Rename fletch -> dartino

pkg/dartino_compiler/lib/src/codegen_visitor.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.codegen_visitor;
+library dartino_compiler.codegen_visitor;
 
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 
 import 'package:compiler/src/resolution/operators.dart' show
     AssignmentOperator,
     BinaryOperator,
     IncDecOperator,
     UnaryOperator;
 
 import 'package:compiler/src/constants/expressions.dart' show
@@ skipping 19 matching lines @@
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/universe/call_structure.dart' show
     CallStructure;
 import 'package:compiler/src/universe/selector.dart' show
     Selector;
 import 'package:compiler/src/diagnostics/spannable.dart' show
     Spannable;
 import 'package:compiler/src/dart_types.dart';
 
-import 'fletch_context.dart';
+import 'dartino_context.dart';
 
-import 'fletch_backend.dart';
+import 'dartino_backend.dart';
 
-import 'fletch_constants.dart' show
-    FletchClassConstant,
-    FletchClassInstanceConstant;
+import 'dartino_constants.dart' show
+    DartinoClassConstant,
+    DartinoClassInstanceConstant;
 
-import 'fletch_function_builder.dart' show
-    FletchFunctionBuilder;
+import 'dartino_function_builder.dart' show
+    DartinoFunctionBuilder;
 
-import 'fletch_class_builder.dart' show
-    FletchClassBuilder;
+import 'dartino_class_builder.dart' show
+    DartinoClassBuilder;
 
-import 'fletch_selector.dart';
+import 'dartino_selector.dart';
 
-import '../fletch_system.dart';
+import '../dartino_system.dart';
 
 import 'closure_environment.dart';
 
-import '../incremental/fletchc_incremental.dart' show
+import '../incremental/dartino_compiler_incremental.dart' show
     IncrementalCompilationFailed; // TODO(ahe): Remove this import.
 
-import 'fletch_registry.dart' show
+import 'dartino_registry.dart' show
     ClosureKind,
-    FletchRegistry;
+    DartinoRegistry;
 
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart' show
     DiagnosticMessage;
 
 import 'package:compiler/src/diagnostics/messages.dart' show
     MessageKind;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
@@ skipping 154 matching lines @@
          InitializerBulkMixin,
          BaseImplementationOfStaticsMixin,
          BaseImplementationOfLocalsMixin,
          SetIfNullBulkMixin
     implements SemanticSendVisitor, SemanticDeclarationVisitor {
   // A literal int can have up to 31 bits of information (32 minus sign).
   static const int LITERAL_INT_MAX = 0x3FFFFFFF;
   static const int MAX_INT64 = (1 << 63) - 1;
   static const int MIN_INT64 = -(1 << 63);
 
-  final FletchContext context;
+  final DartinoContext context;
 
   final ClosureEnvironment closureEnvironment;
 
   final ExecutableElement element;
 
-  final FletchFunctionBuilder functionBuilder;
+  final DartinoFunctionBuilder functionBuilder;
 
   final Map<Element, LocalValue> scope = <Element, LocalValue>{};
 
   final Map<Node, JumpInfo> jumpInfo = <Node, JumpInfo>{};
 
   // Stack of try blocks (inner-most first), in the lexical scope.
   Link<TryBlock> tryBlockStack = const Link<TryBlock>();
 
   VisitState visitState;
   BytecodeLabel trueLabel;
@@ skipping 63 matching lines @@
   int allocateConstantFromNode(Node node, {TreeElements elements}) {
     ConstantExpression expression = compileConstant(
         node,
         elements: elements,
         isConst: false);
     return functionBuilder.allocateConstant(
         context.getConstantValue(expression));
   }
 
   int allocateConstantClassInstance(int classId) {
-    var constant = new FletchClassInstanceConstant(classId);
+    var constant = new DartinoClassInstanceConstant(classId);
     context.markConstantUsed(constant);
     return functionBuilder.allocateConstant(constant);
   }
 
   int allocateStringConstant(String string) {
     return functionBuilder.allocateConstant(
         context.backend.constantSystem.createString(
             new DartString.literal(string)));
   }
 
@@ skipping 69 matching lines @@
   /// various kinds of implicit or explicit closurizations that can occur.
   void registerClosurization(FunctionElement element, ClosureKind kind);
 
   int compileLazyFieldInitializer(FieldElement field);
 
   void invokeMethod(Node node, Selector selector) {
     registerDynamicUse(selector);
     String symbol = context.getSymbolFromSelector(selector);
     int id = context.getSymbolId(symbol);
     int arity = selector.argumentCount;
-    int fletchSelector = FletchSelector.encodeMethod(id, arity);
-    assembler.invokeMethod(fletchSelector, arity, selector.name);
+    int dartinoSelector = DartinoSelector.encodeMethod(id, arity);
+    assembler.invokeMethod(dartinoSelector, arity, selector.name);
   }
 
   void invokeGetter(Node node, Name name) {
     registerDynamicUse(new Selector.getter(name));
     String symbol = context.mangleName(name);
     int id = context.getSymbolId(symbol);
-    int fletchSelector = FletchSelector.encodeGetter(id);
-    assembler.invokeMethod(fletchSelector, 0);
+    int dartinoSelector = DartinoSelector.encodeGetter(id);
+    assembler.invokeMethod(dartinoSelector, 0);
   }
 
   void invokeSetter(Node node, Name name) {
     registerDynamicUse(new Selector.setter(name));
     String symbol = context.mangleName(name);
     int id = context.getSymbolId(symbol);
-    int fletchSelector = FletchSelector.encodeSetter(id);
-    assembler.invokeMethod(fletchSelector, 1);
+    int dartinoSelector = DartinoSelector.encodeSetter(id);
+    assembler.invokeMethod(dartinoSelector, 1);
   }
 
   void invokeFactory(Node node, int constId, int arity) {
     assembler.invokeFactory(constId, arity);
   }
 
   void invokeStatic(Node node, int constId, int arity) {
     assembler.invokeStatic(constId, arity);
   }
 
@@ skipping 21 matching lines @@
     assembler.dup();
     int constId = allocateConstantFromNode(caseMatch.expression);
     assembler.loadConst(constId);
     // For debugging, ignore the equality checks in connection
     // with case matches by not associating the calls with
     // any node.
     invokeMethod(null, new Selector.binaryOperator('=='));
     assembler.branchIfTrue(ifTrue);
   }
 
-  FletchFunctionBase requireFunction(FunctionElement element) {
+  DartinoFunctionBase requireFunction(FunctionElement element) {
     // TODO(johnniwinther): More precise use.
     registerStaticUse(new StaticUse.foreignUse(element));
     return context.backend.getFunctionForElement(element);
   }
 
-  FletchFunctionBase requireConstructorInitializer(
+  DartinoFunctionBase requireConstructorInitializer(
       ConstructorElement constructor) {
     assert(constructor.isGenerativeConstructor);
     registerInstantiatedClass(constructor.enclosingClass);
     registerStaticUse(new StaticUse.foreignUse(constructor));
     return context.backend.getConstructorInitializerFunction(constructor);
   }
 
   void doStaticFunctionInvoke(
       Node node,
-      FletchFunctionBase function,
+      DartinoFunctionBase function,
       NodeList arguments,
       CallStructure callStructure,
       {bool factoryInvoke: false}) {
     if (function.isInstanceMember) loadThis();
     FunctionSignature signature = function.signature;
     int functionId;
     int arity;
     if (signature.hasOptionalParameters &&
         signature.optionalParametersAreNamed) {
-      if (FletchBackend.isExactParameterMatch(signature, callStructure)) {
+      if (DartinoBackend.isExactParameterMatch(signature, callStructure)) {
         functionId = function.functionId;
       } else if (callStructure.signatureApplies(signature)) {
         // TODO(ajohnsen): Inline parameter stub?
-        FletchFunctionBase stub = context.backend.createParameterStub(
+        DartinoFunctionBase stub = context.backend.createParameterStub(
             function,
             callStructure.callSelector);
         functionId = stub.functionId;
       } else {
         doUnresolved(function.name);
         return;
       }
       for (Node argument in arguments) {
         visitForValue(argument);
       }
@@ skipping 410 matching lines @@
       assembler.pop();
       assembler.loadLiteralTrue();
       return;
     }
 
     if (type.isTypedef) {
       // TODO(ajohnsen): This only matches with the number of arguments, not
       // the actual argument types.
       TypedefType typedefType = type;
       int arity = typedefType.element.functionSignature.parameterCount;
-      int fletchSelector = context.toFletchIsSelector(
+      int dartinoSelector = context.toDartinoIsSelector(
           context.backend.compiler.coreClasses.functionClass, arity);
-      assembler.invokeTest(fletchSelector, 0);
+      assembler.invokeTest(dartinoSelector, 0);
       return;
     }
 
     if (!type.isInterfaceType) {
       assembler.pop();
       generateUnimplementedError(
           diagnosticLocation, "Unhandled type test for $type.");
       return;
     }
 
     Element element = type.element;
-    int fletchSelector = context.toFletchIsSelector(element);
-    assembler.invokeTest(fletchSelector, 0);
+    int dartinoSelector = context.toDartinoIsSelector(element);
+    assembler.invokeTest(dartinoSelector, 0);
   }
 
   void doIs(
       Node node,
       Node expression,
       DartType type,
       // TODO(ahe): Remove [diagnosticLocation] when callIsSelector does not
       // require it.
       Spannable diagnosticLocation) {
     visitForValue(expression);
@@ skipping 46 matching lines @@
       visitForValue(argument);
     }
     generateIdentical(node);
   }
 
   void handleStaticFunctionGet(
       Send node,
       MethodElement function,
       _) {
     registerClosurization(function, ClosureKind.tearOff);
-    FletchFunctionBase target = requireFunction(function);
-    FletchClassBuilder classBuilder =
+    DartinoFunctionBase target = requireFunction(function);
+    DartinoClassBuilder classBuilder =
         context.backend.createTearoffClass(target);
     assert(classBuilder.fields == 0);
     int constId = allocateConstantClassInstance(classBuilder.classId);
     assembler.loadConst(constId);
     applyVisitState();
   }
 
   void doMainCall(Send node, NodeList arguments) {
     FunctionElement function = context.compiler.mainFunction;
     if (function.isMalformed) {
@@ skipping 20 matching lines @@
     int argumentCount = 0;
     for (Node argument in arguments) {
       if (argumentCount == parameterCount) break;
       visitForValue(argument);
       argumentCount++;
     }
     for (int i = argumentCount; i < parameterCount; i++) {
       assembler.loadLiteralNull();
     }
 
-    FletchFunctionBase base = requireFunction(function);
+    DartinoFunctionBase base = requireFunction(function);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     invokeStatic(node, constId, parameterCount);
   }
 
   void doStaticallyBoundInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure) {
     if (checkCompileError(element)) return;
     if (element.declaration == context.compiler.identicalFunction) {
       doIdenticalCall(node, arguments);
       return;
     }
     if (element.isExternal) {
       // Patch known functions directly.
-      if (element == context.backend.fletchExternalInvokeMain) {
+      if (element == context.backend.dartinoExternalInvokeMain) {
         doMainCall(node, arguments);
         return;
-      } else if (element == context.backend.fletchExternalCoroutineChange) {
+      } else if (element == context.backend.dartinoExternalCoroutineChange) {
         for (Node argument in arguments) {
           visitForValue(argument);
         }
         assembler.coroutineChange();
         return;
       }
       // TODO(ajohnsen): Define a known set of external functions we allow
       // calls to?
     }
-    FletchFunctionBase target = requireFunction(element);
+    DartinoFunctionBase target = requireFunction(element);
     doStaticFunctionInvoke(node, target, arguments, callStructure);
   }
 
   void handleStaticFunctionInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticallyBoundInvoke(
         node, element.declaration, arguments, callStructure);
     applyVisitState();
   }
 
   void visitSuperMethodInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticallyBoundInvoke(node, element, arguments, callStructure);
     applyVisitState();
   }
 
   void doSuperCall(Node node, FunctionElement function) {
     registerStaticUse(new StaticUse.foreignUse(function));
     int arity = function.functionSignature.parameterCount + 1;
-    FletchFunctionBase base = requireFunction(function);
+    DartinoFunctionBase base = requireFunction(function);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     invokeStatic(node, constId, arity);
   }
 
   void visitSuperGetterGet(
       Send node,
       FunctionElement getter,
       _) {
     loadThis();
     doSuperCall(node, getter);
     applyVisitState();
   }
 
   void visitSuperMethodGet(
       Send node,
       MethodElement method,
       _) {
     registerClosurization(method, ClosureKind.superTearOff);
     loadThis();
-    FletchFunctionBase target = requireFunction(method);
-    FletchClassBuilder classBuilder =
+    DartinoFunctionBase target = requireFunction(method);
+    DartinoClassBuilder classBuilder =
         context.backend.createTearoffClass(target);
     assert(classBuilder.fields == 1);
     int constId = functionBuilder.allocateConstantFromClass(
         classBuilder.classId);
     assembler.allocate(constId, classBuilder.fields);
     applyVisitState();
   }
 
   void visitSuperSetterSet(
       SendSet node,
@@ skipping 113 matching lines @@
       FunctionElement function,
       _) {
     loadThis();
     doSuperCall(node, function);
     applyVisitState();
   }
 
   int computeFieldIndex(FieldElement field) {
     ClassElement classElement = element.enclosingClass;
     int fieldIndex;
-    FletchClassBuilder classBuilder;
+    DartinoClassBuilder classBuilder;
     do {
       // We need to find the mixin application of the class, where the field
       // is stored. Iterate until it's found.
       classBuilder = context.backend.registerClassElement(classElement);
       classElement = classElement.implementation;
       int i = 0;
       classElement.forEachInstanceField((_, FieldElement member) {
         if (member == field) {
           assert(fieldIndex == null);
           fieldIndex = i;
@@ skipping 158 matching lines @@
 
   void visitDynamicPropertyGet(
       Send node,
       Node receiver,
       Name name,
       _) {
     if (name.text == "runtimeType") {
       // TODO(ahe): Implement runtimeType.
       generateUnimplementedError(
           node,
-          "'runtimeType' isn't supported in Fletch. See https://goo.gl/ELH6Zc");
+          "'runtimeType' isn't supported in Dartino. See https://goo.gl/ELH6Zc");
       applyVisitState();
       return;
     }
     visitForValue(receiver);
     invokeGetter(node, name);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertyGet(
       Send node,
@@ skipping 222 matching lines @@
     }
     ClassElement literalClass =
         context.backend.mapImplementation.implementation;
     ConstructorElement constructor = literalClass.lookupConstructor("");
     if (constructor == null) {
       internalError(literalClass, "Failed to lookup default map constructor");
       return;
     }
     // The default constructor is a redirecting factory constructor. Follow it.
     constructor = constructor.effectiveTarget;
-    FletchFunctionBase function = requireFunction(constructor.declaration);
+    DartinoFunctionBase function = requireFunction(constructor.declaration);
     doStaticFunctionInvoke(
         node,
         function,
         new NodeList.empty(),
         CallStructure.NO_ARGS,
         factoryInvoke: true);
 
     Selector selector = new Selector.indexSet();
     for (Node element in node.entries) {
       assembler.dup();
@@ skipping 501 matching lines @@
       // TODO(ahe): It seems suboptimal that each throw is followed by a pop.
       generateThrow(node);
     }
     assembler.pop();
   }
 
   void callConstructor(Node node,
                        ConstructorElement constructor,
                        NodeList arguments,
                        CallStructure callStructure) {
-    FletchFunctionBase function = requireConstructorInitializer(constructor);
+    DartinoFunctionBase function = requireConstructorInitializer(constructor);
     doStaticFunctionInvoke(node, function, arguments, callStructure);
   }
 
   void doConstConstructorInvoke(ConstantExpression constant) {
     var value = context.getConstantValue(constant);
     context.markConstantUsed(value);
     int constId = functionBuilder.allocateConstant(value);
     assembler.loadConst(constId);
   }
 
@@ skipping 63 matching lines @@
           constructor,
           type,
           implementation.effectiveTarget,
           null,
           arguments,
           callStructure,
           null);
       return;
     }
     // TODO(ahe): Remove ".declaration" when issue 23135 is fixed.
-    FletchFunctionBase function = requireFunction(constructor.declaration);
+    DartinoFunctionBase function = requireFunction(constructor.declaration);
     doStaticFunctionInvoke(
         node, function, arguments, callStructure, factoryInvoke: true);
     applyVisitState();
   }
 
   void visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
@@ skipping 89 matching lines @@
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doUnresolved(node.send.toString());
     applyVisitState();
   }
 
   void doStaticGetterGet(Send node, FunctionElement getter) {
-    if (getter == context.backend.fletchExternalNativeError) {
+    if (getter == context.backend.dartinoExternalNativeError) {
       assembler.loadSlot(0);
       return;
     }
 
     if (getter.isDeferredLoaderGetter) {
       generateUnimplementedError(node, "Deferred loading is not supported.");
       return;
     }
 
-    FletchFunctionBase base = requireFunction(getter);
+    DartinoFunctionBase base = requireFunction(getter);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     invokeStatic(node, constId, 0);
   }
 
   void handleStaticGetterGet(Send node, FunctionElement getter, _) {
     doStaticGetterGet(node, getter);
     applyVisitState();
   }
 
   void handleStaticGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticGetterGet(node, getter);
     for (Node argument in arguments) {
       visitForValue(argument);
     }
     invokeMethod(node, callStructure.callSelector);
     applyVisitState();
   }
 
   void handleStaticSetterSet(
       Send node,
       FunctionElement setter,
       Node rhs,
       _) {
     visitForValue(rhs);
-    FletchFunctionBase base = requireFunction(setter);
+    DartinoFunctionBase base = requireFunction(setter);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     invokeStatic(node, constId, 1);
     applyVisitState();
   }
 
   /**
    * Load the captured variables of [function], expressed in [info].
    *
    * If [function] captures itself, its field index is returned.
    */
@@ skipping 28 matching lines @@
   }
 
   void visitFunctionExpression(FunctionExpression node) {
     FunctionElement function = elements[node];
 
     // If the closure captures itself, thisClosureIndex is the field-index in
     // the closure.
     int thisClosureIndex = pushCapturedVariables(function);
     bool needToStoreThisReference = thisClosureIndex >= 0;
 
-    FletchClassBuilder classBuilder = context.backend.createClosureClass(
+    DartinoClassBuilder classBuilder = context.backend.createClosureClass(
         function,
         closureEnvironment);
     int classConstant = functionBuilder.allocateConstantFromClass(
         classBuilder.classId);
 
     // NOTE: Currently we emit a storeField instruction in case a closure
     // captures itself. Changing fields makes it a mutable object.
     // We can therefore not allocate the object with `immutable = true`.
-    // TODO(fletchc-team): Could we restrict this limitation.
+    // TODO(dartino_compiler-team): Could we restrict this limitation.
     bool immutable = !closureEnvironment.closures[function].free.any(
         closureEnvironment.shouldBeBoxed) && !needToStoreThisReference;
 
     assembler.allocate(
         classConstant, classBuilder.fields, immutable: immutable);
 
     if (needToStoreThisReference) {
       assert(!immutable);
       assembler.dup();
       assembler.storeField(thisClosureIndex);
@@ skipping 526 matching lines @@
 
     // Pop exception slot.
     assembler.pop();
   }
 
   void doUnresolved(String name) {
     var constString = context.backend.constantSystem.createString(
         new DartString.literal(name));
     context.markConstantUsed(constString);
     assembler.loadConst(functionBuilder.allocateConstant(constString));
-    FunctionElement function = context.backend.fletchUnresolved;
-    FletchFunctionBase base = requireFunction(function);
+    FunctionElement function = context.backend.dartinoUnresolved;
+    DartinoFunctionBase base = requireFunction(function);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     assembler.invokeStatic(constId, 1);
   }
 
   bool checkCompileError(Element element) {
     DiagnosticMessage message =
         context.compiler.elementsWithCompileTimeErrors[element];
     if (message != null) {
       doCompileError(message);
       return true;
     }
     return false;
   }
 
   String formatError(DiagnosticMessage diagnosticMessage) {
     return diagnosticMessage.message.computeMessage();
   }
 
 
   void doCompileError(DiagnosticMessage errorMessage) {
-    FunctionElement function = context.backend.fletchCompileError;
-    FletchFunctionBase base = requireFunction(function);
+    FunctionElement function = context.backend.dartinoCompileError;
+    DartinoFunctionBase base = requireFunction(function);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     String errorString = formatError(errorMessage);
     ConstantValue stringConstant =
         context.backend.constantSystem.createString(
             new DartString.literal(errorString));
     int messageConstId = functionBuilder.allocateConstant(stringConstant);
     context.markConstantUsed(stringConstant);
     assembler.loadConst(messageConstId);
     registerInstantiatedClass(context.backend.stringImplementation);
     assembler.invokeStatic(constId, 1);
@@ skipping 139 matching lines @@
 
   void applyInitializers(FunctionExpression initializers, _) {
     internalError(initializers, "[applyInitializers] isn't implemented.");
   }
 
   void applyParameters(NodeList parameters, _) {
     internalError(parameters, "[applyParameters] isn't implemented.");
   }
 }
 
-abstract class FletchRegistryMixin {
-  FletchRegistry get registry;
-  FletchContext get context;
+abstract class DartinoRegistryMixin {
+  DartinoRegistry get registry;
+  DartinoContext get context;
 
   void registerDynamicUse(Selector selector) {
     registry.registerDynamicUse(selector);
   }
 
   void registerStaticUse(StaticUse staticUse) {
     registry.registerStaticUse(staticUse);
   }
 
   void registerInstantiatedClass(ClassElement klass) {
@@ skipping 16 matching lines @@
       // is a getter. This happens for both named and unnamed.
       registerStaticUse(new StaticUse.foreignUse(element));
     }
     registry.registerClosurization(element, kind);
   }
 
   int compileLazyFieldInitializer(FieldElement field) {
     return context.backend.compileLazyFieldInitializer(field, registry);
   }
 }