Rename fletch -> dartino

pkg/dartino_compiler/lib/src/constructor_codegen.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.constructor_codegen;
+library dartino_compiler.constructor_codegen;
 
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/tree_elements.dart' show
     TreeElements;
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/universe/call_structure.dart' show
     CallStructure;
 import 'package:compiler/src/dart_types.dart';
 
-import 'fletch_context.dart';
+import 'dartino_context.dart';
 
-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 'closure_environment.dart';
 
 import 'lazy_field_initializer_codegen.dart';
 
 import 'codegen_visitor.dart';
 
-import 'fletch_registry.dart' show
-    FletchRegistry;
+import 'dartino_registry.dart' show
+    DartinoRegistry;
 
-class ConstructorCodegen extends CodegenVisitor with FletchRegistryMixin {
-  final FletchRegistry registry;
+class ConstructorCodegen extends CodegenVisitor with DartinoRegistryMixin {
+  final DartinoRegistry registry;
 
-  final FletchClassBuilder classBuilder;
+  final DartinoClassBuilder classBuilder;
 
   final Map<FieldElement, LocalValue> fieldScope = <FieldElement, LocalValue>{};
 
   final List<ConstructorElement> constructors = <ConstructorElement>[];
 
   ClosureEnvironment initializerClosureEnvironment;
 
-  ConstructorCodegen(FletchFunctionBuilder functionBuilder,
-                     FletchContext context,
+  ConstructorCodegen(DartinoFunctionBuilder functionBuilder,
+                     DartinoContext context,
                      TreeElements elements,
                      this.registry,
                      ClosureEnvironment closureEnvironment,
                      ConstructorElement constructor,
                      this.classBuilder)
       : super(functionBuilder, context, elements,
               closureEnvironment, constructor);
 
   ConstructorElement get constructor => element;
 
@@ skipping 18 matching lines @@
     int parameterCount = signature.parameterCount;
 
     // Visit constructor and evaluate initializers and super calls. The
     // arguments to the constructor are located before the return address.
     inlineInitializers(constructor, -parameterCount - 1);
 
     handleAllocationAndBodyCall();
   }
 
   LazyFieldInitializerCodegen lazyFieldInitializerCodegenFor(
-      FletchFunctionBuilder function,
+      DartinoFunctionBuilder function,
       FieldElement field) {
     TreeElements elements = field.resolvedAst.elements;
     return new LazyFieldInitializerCodegen(
         function,
         context,
         elements,
         registry,
         context.backend.createClosureEnvironment(field, elements),
         field);
   }
@@ skipping 246 matching lines @@
       // Boxed parameters are passed as boxed objects, not as the values
       // contained within like we do for ordinary invokes
       scope[parameter].loadRaw(assembler);
     });
 
     assembler
         ..invokeStatic(constructorId, 1 + signature.parameterCount)
         ..pop();
   }
 
-  void pushInitialFieldValues(FletchClassBuilder classBuilder) {
+  void pushInitialFieldValues(DartinoClassBuilder classBuilder) {
     if (classBuilder.hasSuperClass) {
       pushInitialFieldValues(classBuilder.superclass);
     }
     int fieldIndex = classBuilder.superclassFields;
     ClassElement classElement = classBuilder.element.implementation;
     classElement.forEachInstanceField((_, FieldElement field) {
       fieldScope[field] = new UnboxedLocalValue(fieldIndex++, field);
       Expression initializer = field.initializer;
       if (initializer == null) {
         assembler.loadLiteralNull();
       } else {
         // Create a LazyFieldInitializerCodegen for compiling the initializer.
         // Note that we reuse the functionBuilder, to inline it into the
         // constructor.
         LazyFieldInitializerCodegen codegen =
             lazyFieldInitializerCodegenFor(functionBuilder, field);
 
         // We only want the value of the actual initializer, not the usual
         // 'body'.
         codegen.visitForValue(initializer);
       }
     });
     assert(fieldIndex <= classBuilder.fields);
   }
 }