Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/constructor_codegen.dart

 // Copyright (c) 2015, the Fletch 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;
 
 import 'package:compiler/src/constants/expressions.dart' show
     ConstantExpression;
 
 import 'package:compiler/src/dart2jslib.dart' show
     MessageKind,
     Registry;
 
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/resolution.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/universe/universe.dart';
 import 'package:compiler/src/util/util.dart' show Spannable;
 import 'package:compiler/src/dart_types.dart';
 
 import 'fletch_context.dart';
 
 import 'fletch_backend.dart';
 
 import 'fletch_constants.dart' show
-    CompiledFunctionConstant,
+    FletchFunctionBuilderConstant,
     FletchClassConstant;
 
 import '../bytecodes.dart' show
     Bytecode;
 
-import 'compiled_function.dart' show
-    CompiledFunction;
+import 'fletch_function_builder.dart' show
+    FletchFunctionBuilder;
 
-import 'compiled_class.dart' show
-    CompiledClass;
+import 'fletch_class_builder.dart' show
+    FletchClassBuilder;
 
 import 'closure_environment.dart';
 
 import 'lazy_field_initializer_codegen.dart';
 
 import 'codegen_visitor.dart';
 
 class ConstructorCodegen extends CodegenVisitor {
-  final CompiledClass compiledClass;
+  final FletchClassBuilder classBuilder;
 
   final Map<FieldElement, LocalValue> fieldScope = <FieldElement, LocalValue>{};
 
   final List<ConstructorElement> constructors = <ConstructorElement>[];
 
   TreeElements initializerElements;
 
-  ConstructorCodegen(CompiledFunction compiledFunction,
+  ConstructorCodegen(FletchFunctionBuilder functionBuilder,
                      FletchContext context,
                      TreeElements elements,
                      Registry registry,
                      ClosureEnvironment closureEnvironment,
                      ConstructorElement constructor,
-                     this.compiledClass)
-      : super(compiledFunction, context, elements, registry,
+                     this.classBuilder)
+      : super(functionBuilder, context, elements, registry,
               closureEnvironment, constructor);
 
   ConstructorElement get constructor => element;
 
-  BytecodeBuilder get builder => compiledFunction.builder;
+  BytecodeBuilder get builder => functionBuilder.builder;
 
   TreeElements get elements {
     if (initializerElements != null) return initializerElements;
     return super.elements;
   }
 
   void compile() {
     // Push all initial field values (including super-classes).
-    pushInitialFieldValues(compiledClass);
+    pushInitialFieldValues(classBuilder);
     // The stack is now:
     //  Value for field-0
     //  ...
     //  Value for field-n
     //
     FunctionSignature signature = constructor.functionSignature;
     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(
-      CompiledFunction function,
+      FletchFunctionBuilder function,
       FieldElement field) {
     TreeElements elements = field.resolvedAst.elements;
     return new LazyFieldInitializerCodegen(
         function,
         context,
         elements,
         registry,
         context.backend.createClosureEnvironment(field, elements),
         field);
   }
 
   void handleAllocationAndBodyCall() {
     // TODO(ajohnsen): Let allocate take an offset to the field stack, so we
     // don't have to copy all the fields?
     // Copy all the fields to the end of the stack.
-    int fields = compiledClass.fields;
+    int fields = classBuilder.fields;
     for (int i = 0; i < fields; i++) {
       builder.loadSlot(i);
     }
 
     // The stack is now:
     //  Value for field-0
     //  ...
     //  Value for field-n
     //  [super arguments]
     //  Value for field-0
     //  ...
     //  Value for field-n
 
     // Create the actual instance.
-    int classConstant = compiledFunction.allocateConstantFromClass(
-        compiledClass.id);
+    int classConstant = functionBuilder.allocateConstantFromClass(
+        classBuilder.id);
     // TODO(ajohnsen): Set immutable for all-final classes.
     builder.allocate(classConstant, fields, immutable: element.isConst);
 
     // The stack is now:
     //  Value for field-0
     //  ...
     //  Value for field-n
     //  [super arguments]
     //  instance
 
@@ skipping 190 matching lines @@
     return argumentCount + signature.parameterCount;
   }
 
   void callConstructorBody(ConstructorElement constructor) {
     FunctionExpression node = constructor.node;
     if (node == null || node.body.asEmptyStatement() != null) return;
 
     registerStaticInvocation(constructor.declaration);
 
     int methodId = context.backend.functionMethodId(constructor);
-    int constructorId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constructorId = functionBuilder.allocateConstantFromFunction(methodId);
 
     FunctionSignature signature = constructor.functionSignature;
 
     // Prepare for constructor body invoke.
     builder.dup();
     signature.orderedForEachParameter((FormalElement parameter) {
       scope[parameter].load(builder);
     });
 
     builder
         ..invokeStatic(constructorId, 1 + signature.parameterCount)
         ..pop();
   }
 
-  void pushInitialFieldValues(CompiledClass compiledClass) {
-    if (compiledClass.hasSuperClass) {
-      pushInitialFieldValues(compiledClass.superclass);
+  void pushInitialFieldValues(FletchClassBuilder classBuilder) {
+    if (classBuilder.hasSuperClass) {
+      pushInitialFieldValues(classBuilder.superclass);
     }
-    int fieldIndex = compiledClass.superclassFields;
-    ClassElement classElement = compiledClass.element.implementation;
+    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) {
         builder.loadLiteralNull();
       } else {
         // Create a LazyFieldInitializerCodegen for compiling the initializer.
-        // Note that we reuse the compiledFunction, to inline it into the
+        // Note that we reuse the functionBuilder, to inline it into the
         // constructor.
         LazyFieldInitializerCodegen codegen =
-            lazyFieldInitializerCodegenFor(compiledFunction, field);
+            lazyFieldInitializerCodegenFor(functionBuilder, field);
 
         // We only want the value of the actual initializer, not the usual
         // 'body'.
         codegen.visitForValue(initializer);
       }
     });
   }
 }