Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/fletch_backend.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.fletch_backend;
 
 import 'dart:async' show
     Future;
 
 import 'package:compiler/src/dart2jslib.dart' show
@@ skipping 70 matching lines @@
     TreeElements;
 
 import 'package:compiler/src/library_loader.dart' show
     LibraryLoader;
 
 import 'fletch_constants.dart' show
     FletchClassConstant,
     FletchFunctionConstant,
     FletchClassInstanceConstant;
 
-import 'compiled_function.dart' show
-    CompiledFunctionKind,
-    CompiledFunction,
+import 'fletch_function_builder.dart' show
+    FletchFunctionBuilderKind,
+    FletchFunctionBuilder,
     DebugInfo;
 
-import 'compiled_class.dart' show
-    CompiledClass;
+import 'fletch_class_builder.dart' show
+    FletchClassBuilder;
 
 import 'codegen_visitor.dart';
 import 'debug_info.dart';
 import 'debug_info_constructor_codegen.dart';
 import 'debug_info_function_codegen.dart';
 import 'debug_info_lazy_field_initializer_codegen.dart';
 import 'fletch_context.dart';
 import 'fletch_selector.dart';
 import 'function_codegen.dart';
 import 'lazy_field_initializer_codegen.dart';
 import 'constructor_codegen.dart';
 import 'closure_environment.dart';
 import '../bytecodes.dart';
 import '../commands.dart';
 
 class FletchBackend extends Backend {
   static const String growableListName = '_GrowableList';
   static const String constantListName = '_ConstantList';
   static const String constantMapName = '_ConstantMap';
   static const String linkedHashMapName = '_CompactLinkedHashMap';
   static const String noSuchMethodName = '_noSuchMethod';
   static const String noSuchMethodTrampolineName = '_noSuchMethodTrampoline';
 
   final FletchContext context;
 
   final DartConstantTask constantCompilerTask;
 
-  final Map<FunctionElement, CompiledFunction> compiledFunctions =
-      <FunctionElement, CompiledFunction>{};
+  final Map<FunctionElement, FletchFunctionBuilder> functionBuilders =
+      <FunctionElement, FletchFunctionBuilder>{};
 
-  final Map<ConstructorElement, CompiledFunction> constructors =
-      <ConstructorElement, CompiledFunction>{};
+  final Map<ConstructorElement, FletchFunctionBuilder> constructors =
+      <ConstructorElement, FletchFunctionBuilder>{};
 
-  final List<CompiledFunction> functions = <CompiledFunction>[];
+  final List<FletchFunctionBuilder> functions = <FletchFunctionBuilder>[];
 
   final Set<FunctionElement> externals = new Set<FunctionElement>();
 
-  final Map<ClassElement, CompiledClass> compiledClasses =
-      <ClassElement, CompiledClass>{};
+  final Map<ClassElement, FletchClassBuilder> classBuilderes =
+      <ClassElement, FletchClassBuilder>{};
   final Map<ClassElement, Set<ClassElement>> directSubclasses =
       <ClassElement, Set<ClassElement>>{};
 
-  final List<CompiledClass> classes = <CompiledClass>[];
+  final List<FletchClassBuilder> classes = <FletchClassBuilder>[];
 
   final Set<ClassElement> builtinClasses = new Set<ClassElement>();
 
   final Map<MemberElement, ClosureEnvironment> closureEnvironments =
       <MemberElement, ClosureEnvironment>{};
 
-  final Map<FunctionElement, CompiledClass> closureClasses =
-      <FunctionElement, CompiledClass>{};
+  final Map<FunctionElement, FletchClassBuilder> closureClasses =
+      <FunctionElement, FletchClassBuilder>{};
 
-  final Map<FieldElement, CompiledFunction> lazyFieldInitializers =
-      <FieldElement, CompiledFunction>{};
+  final Map<FieldElement, FletchFunctionBuilder> lazyFieldInitializers =
+      <FieldElement, FletchFunctionBuilder>{};
 
-  final Map<CompiledFunction, CompiledClass> tearoffClasses =
-      <CompiledFunction, CompiledClass>{};
+  final Map<FletchFunctionBuilder, FletchClassBuilder> tearoffClasses =
+      <FletchFunctionBuilder, FletchClassBuilder>{};
 
   final Map<int, int> getters = <int, int>{};
   final Map<int, int> setters = <int, int>{};
 
-  Map<CompiledClass, CompiledFunction> tearoffFunctions;
+  Map<FletchClassBuilder, FletchFunctionBuilder> tearoffFunctions;
 
   List<Command> commands;
 
   LibraryElement fletchSystemLibrary;
   LibraryElement fletchFFILibrary;
   LibraryElement fletchIOSystemLibrary;
   LibraryElement collectionLibrary;
   LibraryElement mathLibrary;
 
   FunctionElement fletchSystemEntry;
 
   FunctionElement fletchExternalInvokeMain;
 
   FunctionElement fletchExternalYield;
 
   FunctionElement fletchExternalNativeError;
 
   FunctionElement fletchExternalCoroutineChange;
 
   FunctionElement fletchUnresolved;
   FunctionElement fletchCompileError;
 
-  CompiledClass compiledObjectClass;
+  FletchClassBuilder compiledObjectClass;
 
   ClassElement stringClass;
   ClassElement smiClass;
   ClassElement mintClass;
   ClassElement growableListClass;
   ClassElement linkedHashMapClass;
   ClassElement coroutineClass;
 
   final Set<FunctionElement> alwaysEnqueue = new Set<FunctionElement>();
 
   FletchBackend(FletchCompiler compiler)
       : this.context = compiler.context,
         this.constantCompilerTask = new DartConstantTask(compiler),
         super(compiler) {
     context.resolutionCallbacks = new FletchResolutionCallbacks(context);
   }
 
-  CompiledClass registerClassElement(ClassElement element) {
+  FletchClassBuilder registerClassElement(ClassElement element) {
     if (element == null) return null;
     assert(element.isDeclaration);
-    return compiledClasses.putIfAbsent(element, () {
+    return classBuilderes.putIfAbsent(element, () {
       directSubclasses[element] = new Set<ClassElement>();
-      CompiledClass superclass = registerClassElement(element.superclass);
+      FletchClassBuilder superclass = registerClassElement(element.superclass);
       if (superclass != null) {
         Set<ClassElement> subclasses = directSubclasses[element.superclass];
         subclasses.add(element);
       }
       int id = classes.length;
-      CompiledClass compiledClass = new CompiledClass(id, element, superclass);
+      FletchClassBuilder classBuilder = new FletchClassBuilder(
+          id, element, superclass);
       if (element.lookupLocalMember(Compiler.CALL_OPERATOR_NAME) != null) {
-        compiledClass.createIsFunctionEntry(this);
+        classBuilder.createIsFunctionEntry(this);
       }
-      classes.add(compiledClass);
-      return compiledClass;
+      classes.add(classBuilder);
+      return classBuilder;
     });
   }
 
-  CompiledClass createCallableStubClass(int fields, CompiledClass superclass) {
+  FletchClassBuilder createCallableStubClass(
+      int fields, FletchClassBuilder superclass) {
     int id = classes.length;
-    CompiledClass compiledClass = new CompiledClass(
+    FletchClassBuilder classBuilder = new FletchClassBuilder(
         id, null, superclass, extraFields: fields);
-    classes.add(compiledClass);
-    compiledClass.createIsFunctionEntry(this);
-    return compiledClass;
+    classes.add(classBuilder);
+    classBuilder.createIsFunctionEntry(this);
+    return classBuilder;
   }
 
   FletchResolutionCallbacks get resolutionCallbacks {
     return context.resolutionCallbacks;
   }
 
   List<CompilerTask> get tasks => <CompilerTask>[];
 
   ConstantSystem get constantSystem {
     return constantCompilerTask.constantCompiler.constantSystem;
@@ skipping 37 matching lines @@
     }
     fletchExternalInvokeMain = findExternal('invokeMain');
     fletchExternalYield = findExternal('yield');
     fletchExternalCoroutineChange = findExternal('coroutineChange');
     fletchExternalNativeError = findExternal('nativeError');
     fletchUnresolved = findExternal('unresolved');
     world.registerStaticUse(fletchUnresolved);
     fletchCompileError = findExternal('compileError');
     world.registerStaticUse(fletchCompileError);
 
-    CompiledClass loadClass(String name, LibraryElement library) {
+    FletchClassBuilder loadClass(String name, LibraryElement library) {
       var classImpl = library.findLocal(name);
       if (classImpl == null) classImpl = library.implementation.find(name);
       if (classImpl == null) {
         compiler.internalError(library, "Internal class '$name' not found.");
         return null;
       }
       // TODO(ahe): Register in ResolutionCallbacks. The 3 lines below should
       // not happen at this point in time.
       classImpl.ensureResolved(compiler);
-      CompiledClass compiledClass = registerClassElement(classImpl);
+      FletchClassBuilder classBuilder = registerClassElement(classImpl);
       world.registerInstantiatedType(classImpl.rawType, registry);
       // TODO(ahe): This is a hack to let both the world and the codegen know
       // about the instantiated type.
       registry.registerInstantiatedType(classImpl.rawType);
-      return compiledClass;
+      return classBuilder;
     }
 
-    CompiledClass loadBuiltinClass(String name, LibraryElement library) {
-      CompiledClass compiledClass = loadClass(name, library);
-      builtinClasses.add(compiledClass.element);
-      return compiledClass;
+    FletchClassBuilder loadBuiltinClass(String name, LibraryElement library) {
+      FletchClassBuilder classBuilder = loadClass(name, library);
+      builtinClasses.add(classBuilder.element);
+      return classBuilder;
     }
 
     compiledObjectClass = loadBuiltinClass("Object", compiler.coreLibrary);
     smiClass = loadBuiltinClass("_Smi", compiler.coreLibrary).element;
     mintClass = loadBuiltinClass("_Mint", compiler.coreLibrary).element;
     stringClass = loadBuiltinClass("_StringImpl", compiler.coreLibrary).element;
     // TODO(ahe): Register _ConstantList through ResolutionCallbacks.
     loadBuiltinClass(constantListName, fletchSystemLibrary);
     loadBuiltinClass(constantMapName, fletchSystemLibrary);
     loadBuiltinClass("_DoubleImpl", compiler.coreLibrary);
@@ skipping 48 matching lines @@
   /// The patch parser (pkg/compiler/lib/src/patch_parser.dart). The patch
   /// parser looks for an annotation on the form "@patch", where "patch" is
   /// compile-time constant instance of [patchAnnotationClass].
   ClassElement get patchAnnotationClass {
     // TODO(ahe): Introduce a proper constant class to identify constants. For
     // now, we simply put "const patch = "patch";" in the beginning of patch
     // files.
     return super.stringImplementation;
   }
 
-  CompiledClass createClosureClass(
+  FletchClassBuilder createClosureClass(
       FunctionElement closure,
       ClosureEnvironment closureEnvironment) {
     return closureClasses.putIfAbsent(closure, () {
       ClosureInfo info = closureEnvironment.closures[closure];
       int fields = info.free.length;
       if (info.isThisFree) fields++;
       return createCallableStubClass(fields, compiledObjectClass);
     });
   }
 
   /**
    * Create a tearoff class for function [function].
    *
    * The class will have one method named 'call', accepting the same arguments
    * as [function]. The method will load the arguments received and statically
    * call [function] (essential a tail-call).
    *
    * If [function] is an instance member, the class will have one field, the
    * instance.
    */
-  CompiledClass createTearoffClass(CompiledFunction function) {
+  FletchClassBuilder createTearoffClass(FletchFunctionBuilder function) {
     return tearoffClasses.putIfAbsent(function, () {
       FunctionSignature signature = function.signature;
       bool hasThis = function.hasThisArgument;
-      CompiledClass compiledClass = createCallableStubClass(
+      FletchClassBuilder classBuilder = createCallableStubClass(
           hasThis ? 1 : 0,
           compiledObjectClass);
-      CompiledFunction compiledFunction = new CompiledFunction(
+      FletchFunctionBuilder functionBuilder = new FletchFunctionBuilder(
           functions.length,
           'call',
           null,
           signature,
-          compiledClass);
-      functions.add(compiledFunction);
+          classBuilder);
+      functions.add(functionBuilder);
 
-      BytecodeBuilder builder = compiledFunction.builder;
+      BytecodeBuilder builder = functionBuilder.builder;
       int argumentCount = signature.parameterCount;
       if (hasThis) {
         argumentCount++;
         // If the tearoff has a 'this' value, load it. It's the only field
         // in the tearoff class.
         builder
             ..loadParameter(0)
             ..loadField(0);
       }
       for (int i = 0; i < signature.parameterCount; i++) {
         // The closure-class is at parameter index 0, so argument i is at
         // i + 1.
         builder.loadParameter(i + 1);
       }
-      int constId = compiledFunction.allocateConstantFromFunction(
+      int constId = functionBuilder.allocateConstantFromFunction(
           function.methodId);
       // TODO(ajohnsen): Create a tail-call bytecode, so we don't have to
       // load all the arguments.
       builder
           ..invokeStatic(constId, argumentCount)
           ..ret()
           ..methodEnd();
 
       String symbol = context.getCallSymbol(signature);
       int id = context.getSymbolId(symbol);
       int fletchSelector = FletchSelector.encodeMethod(
           id,
           signature.parameterCount);
-      compiledClass.addToMethodTable(fletchSelector, compiledFunction);
+      classBuilder.addToMethodTable(fletchSelector, functionBuilder);
 
       if (hasThis && function.memberOf.element != null) {
         // Create == function that tests for equality.
         int isSelector = context.toFletchTearoffIsSelector(
             function.name,
             function.memberOf.element);
-        compiledClass.addIsSelector(isSelector);
+        classBuilder.addIsSelector(isSelector);
 
-        CompiledFunction equal = new CompiledFunction.normal(
+        FletchFunctionBuilder equal = new FletchFunctionBuilder.normal(
             functions.length,
             2);
         functions.add(equal);
 
         BytecodeLabel isFalse = new BytecodeLabel();
         equal.builder
           // First test for class. This ensures it's the exact function that
           // we expect.
           ..loadParameter(1)
           ..invokeTest(isSelector, 0)
           ..branchIfFalse(isFalse)
           // Then test that the receiver is identical.
           ..loadParameter(0)
           ..loadField(0)
           ..loadParameter(1)
           ..loadField(0)
           ..identicalNonNumeric()
           ..branchIfFalse(isFalse)
           ..loadLiteralTrue()
           ..ret()
           ..bind(isFalse)
           ..loadLiteralFalse()
           ..ret()
           ..methodEnd();
 
         int id = context.getSymbolId("==");
         int equalsSelector = FletchSelector.encodeMethod(id, 1);
-        compiledClass.addToMethodTable(equalsSelector, equal);
+        classBuilder.addToMethodTable(equalsSelector, equal);
 
         // Create hashCode getter. We simply xor the object hashCode and the
         // method id of the tearoff'ed function.
-        CompiledFunction hashCode = new CompiledFunction.accessor(
+        FletchFunctionBuilder hashCode = new FletchFunctionBuilder.accessor(
             functions.length,
             false);
         functions.add(hashCode);
 
         int hashCodeSelector = FletchSelector.encodeGetter(
             context.getSymbolId("hashCode"));
         int xorSelector = FletchSelector.encodeMethod(
             context.getSymbolId("^"), 1);
         hashCode.builder
           ..loadParameter(0)
           ..loadField(0)
           ..invokeMethod(hashCodeSelector, 0)
           ..loadLiteral(function.methodId)
           ..invokeMethod(xorSelector, 1)
           ..ret()
           ..methodEnd();
 
-        compiledClass.addToMethodTable(hashCodeSelector, hashCode);
+        classBuilder.addToMethodTable(hashCodeSelector, hashCode);
       }
-      return compiledClass;
+      return classBuilder;
     });
   }
 
-  CompiledFunction createCompiledFunction(FunctionElement function) {
+  FletchFunctionBuilder createFletchFunctionBuilder(FunctionElement function) {
     assert(function.memberContext == function);
 
-    CompiledClass holderClass;
+    FletchClassBuilder holderClass;
     if (function.isInstanceMember || function.isGenerativeConstructor) {
       ClassElement enclosingClass = function.enclosingClass.declaration;
       holderClass = registerClassElement(enclosingClass);
     }
-    return internalCreateCompiledFunction(
+    return internalCreateFletchFunctionBuilder(
         function,
         function.name,
         holderClass);
   }
 
-  CompiledFunction internalCreateCompiledFunction(
+  FletchFunctionBuilder internalCreateFletchFunctionBuilder(
       FunctionElement function,
       String name,
-      CompiledClass holderClass) {
-    return compiledFunctions.putIfAbsent(function.declaration, () {
+      FletchClassBuilder holderClass) {
+    return functionBuilders.putIfAbsent(function.declaration, () {
       FunctionTypedElement implementation = function.implementation;
-      CompiledFunction compiledFunction = new CompiledFunction(
+      FletchFunctionBuilder functionBuilder = new FletchFunctionBuilder(
           functions.length,
           name,
           function,
           // Parameter initializers are expressed in the potential
           // implementation.
           implementation.functionSignature,
           holderClass,
           kind: function.isAccessor
-              ? CompiledFunctionKind.ACCESSOR
-              : CompiledFunctionKind.NORMAL);
-      functions.add(compiledFunction);
-      return compiledFunction;
+              ? FletchFunctionBuilderKind.ACCESSOR
+              : FletchFunctionBuilderKind.NORMAL);
+      functions.add(functionBuilder);
+      return functionBuilder;
     });
   }
 
   int functionMethodId(FunctionElement function) {
-    return createCompiledFunction(function).methodId;
+    return createFletchFunctionBuilder(function).methodId;
   }
 
-  CompiledFunction compiledFunctionFromTearoffClass(CompiledClass klass) {
+  FletchFunctionBuilder functionBuilderFromTearoffClass(
+      FletchClassBuilder klass) {
     if (tearoffFunctions == null) {
-      tearoffFunctions = <CompiledClass, CompiledFunction>{};
+      tearoffFunctions = <FletchClassBuilder, FletchFunctionBuilder>{};
       tearoffClasses.forEach((k, v) => tearoffFunctions[v] = k);
     }
     return tearoffFunctions[klass];
   }
 
-  void ensureDebugInfo(CompiledFunction function) {
+  void ensureDebugInfo(FletchFunctionBuilder function) {
     if (function.debugInfo != null) return;
     function.debugInfo = new DebugInfo(function);
     AstElement element = function.element;
     if (element == null) return;
     List<Bytecode> expectedBytecodes = function.builder.bytecodes;
     element = element.implementation;
     TreeElements elements = element.resolvedAst.elements;
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         element,
         elements);
     CodegenVisitor codegen;
     if (function.isLazyFieldInitializer) {
       codegen = new DebugInfoLazyFieldInitializerCodegen(
           function,
           context,
           elements,
           null,
           closureEnvironment,
           element,
           compiler);
     } else if (function.isInitializerList) {
       ClassElement enclosingClass = element.enclosingClass;
-      CompiledClass compiledClass = compiledClasses[enclosingClass];
+      FletchClassBuilder classBuilder = classBuilderes[enclosingClass];
       codegen = new DebugInfoConstructorCodegen(
           function,
           context,
           elements,
           null,
           closureEnvironment,
           element,
-          compiledClass,
+          classBuilder,
           compiler);
     } else {
       codegen = new DebugInfoFunctionCodegen(
           function,
           context,
           elements,
           null,
           closureEnvironment,
           element,
           compiler);
@@ skipping 42 matching lines @@
   void codegenFunction(
       FunctionElement function,
       TreeElements elements,
       Registry registry) {
     registry.registerStaticInvocation(fletchSystemEntry);
 
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         function,
         elements);
 
-    CompiledFunction compiledFunction;
+    FletchFunctionBuilder functionBuilder;
 
     if (function.memberContext != function) {
-      compiledFunction = internalCreateCompiledFunction(
+      functionBuilder = internalCreateFletchFunctionBuilder(
           function,
           Compiler.CALL_OPERATOR_NAME,
           createClosureClass(function, closureEnvironment));
     } else {
-      compiledFunction = createCompiledFunction(function);
+      functionBuilder = createFletchFunctionBuilder(function);
     }
 
     FunctionCodegen codegen = new FunctionCodegen(
-        compiledFunction,
+        functionBuilder,
         context,
         elements,
         registry,
         closureEnvironment,
         function);
 
     if (isNative(function)) {
       codegenNativeFunction(function, codegen);
     } else if (isExternal(function)) {
       codegenExternalFunction(function, codegen);
     } else {
       codegen.compile();
     }
 
     // TODO(ahe): Don't do this.
     compiler.enqueuer.codegen.generatedCode[function.declaration] = null;
 
-    if (compiledFunction.memberOf != null &&
+    if (functionBuilder.memberOf != null &&
         !function.isGenerativeConstructor) {
       // Inject the function into the method table of the 'holderClass' class.
       // Note that while constructor bodies has a this argument, we don't inject
       // them into the method table.
       String symbol = context.getSymbolForFunction(
-          compiledFunction.name,
+          functionBuilder.name,
           function.functionSignature,
           function.library);
       int id = context.getSymbolId(symbol);
       int arity = function.functionSignature.parameterCount;
       SelectorKind kind = SelectorKind.Method;
       if (function.isGetter) kind = SelectorKind.Getter;
       if (function.isSetter) kind = SelectorKind.Setter;
       int fletchSelector = FletchSelector.encode(id, kind, arity);
-      int methodId = compiledFunction.methodId;
-      compiledFunction.memberOf.addToMethodTable(
-          fletchSelector, compiledFunction);
+      int methodId = functionBuilder.methodId;
+      functionBuilder.memberOf.addToMethodTable(
+          fletchSelector, functionBuilder);
       // Inject method into all mixin usages.
       Iterable<ClassElement> mixinUsage =
           compiler.world.mixinUsesOf(function.enclosingClass);
       for (ClassElement usage in mixinUsage) {
         // TODO(ajohnsen): Consider having multiple 'memberOf' in
-        // CompiledFunction, to avoid duplicates.
+        // FletchFunctionBuilder, to avoid duplicates.
         // Create a copy with a unique 'memberOf', so we can detect missing
         // stubs for the mixin applications as well.
-        CompiledClass compiledUsage = registerClassElement(usage);
+        FletchClassBuilder compiledUsage = registerClassElement(usage);
         FunctionTypedElement implementation = function.implementation;
-        CompiledFunction copy = new CompiledFunction(
+        FletchFunctionBuilder copy = new FletchFunctionBuilder(
             functions.length,
             function.name,
             implementation,
             implementation.functionSignature,
             compiledUsage,
             kind: function.isAccessor
-                ? CompiledFunctionKind.ACCESSOR
-                : CompiledFunctionKind.NORMAL);
+                ? FletchFunctionBuilderKind.ACCESSOR
+                : FletchFunctionBuilderKind.NORMAL);
         functions.add(copy);
         compiledUsage.addToMethodTable(fletchSelector, copy);
-        copy.copyFrom(compiledFunction);
+        copy.copyFrom(functionBuilder);
       }
     }
 
     if (compiler.verbose) {
-      compiler.log(compiledFunction.verboseToString());
+      compiler.log(functionBuilder.verboseToString());
     }
   }
 
   void codegenNativeFunction(
       FunctionElement function,
       FunctionCodegen codegen) {
     String name = '.${function.name}';
 
     ClassElement enclosingClass = function.enclosingClass;
     if (enclosingClass != null) name = '${enclosingClass.name}$name';
@@ skipping 120 matching lines @@
     MemberElement member = element.memberContext;
     return closureEnvironments.putIfAbsent(member, () {
       ClosureVisitor environment = new ClosureVisitor(member, elements);
       return environment.compute();
     });
   }
 
   void createParameterMatchingStubs() {
     int length = functions.length;
     for (int i = 0; i < length; i++) {
-      CompiledFunction function = functions[i];
+      FletchFunctionBuilder function = functions[i];
       if (!function.hasThisArgument || function.isAccessor) continue;
       String name = function.name;
       Set<Selector> usage = compiler.resolverWorld.invokedNames[name];
       if (usage == null) continue;
       for (Selector use in usage) {
         // TODO(ajohnsen): Somehow filter out private selectors of other
         // libraries.
         if (function.canBeCalledAs(use) &&
             !function.matchesSelector(use)) {
           function.createParameterMappingFor(use, context);
         }
       }
     }
   }
 
   void createTearoffStubs() {
     int length = functions.length;
     for (int i = 0; i < length; i++) {
-      CompiledFunction function = functions[i];
+      FletchFunctionBuilder function = functions[i];
       if (!function.hasThisArgument || function.isAccessor) continue;
       String name = function.name;
       if (compiler.resolverWorld.invokedGetters.containsKey(name)) {
         createTearoffGetterForFunction(function);
       }
     }
   }
 
-  void createTearoffGetterForFunction(CompiledFunction function) {
-    CompiledClass tearoffClass = createTearoffClass(function);
-    CompiledFunction getter = new CompiledFunction.accessor(
+  void createTearoffGetterForFunction(FletchFunctionBuilder function) {
+    FletchClassBuilder tearoffClass = createTearoffClass(function);
+    FletchFunctionBuilder getter = new FletchFunctionBuilder.accessor(
         functions.length,
         false);
     functions.add(getter);
     int constId = getter.allocateConstantFromClass(tearoffClass.id);
     getter.builder
         ..loadParameter(0)
         ..allocate(constId, tearoffClass.fields)
         ..ret()
         ..methodEnd();
     // If the name is private, we need the library.
     // Invariant: We only generate public stubs, e.g. 'call'.
     LibraryElement library;
     if (function.memberOf.element != null) {
       library = function.memberOf.element.library;
     }
     int fletchSelector = context.toFletchSelector(
         new Selector.getter(function.name, library));
     function.memberOf.addToMethodTable(fletchSelector, getter);
   }
 
   int assembleProgram() {
     createTearoffStubs();
     createParameterMatchingStubs();
 
-    for (CompiledClass compiledClass in classes) {
-      compiledClass.createIsEntries(this);
+    for (FletchClassBuilder classBuilder in classes) {
+      classBuilder.createIsEntries(this);
       // TODO(ajohnsen): Currently, the CodegenRegistry does not enqueue fields.
       // This is a workaround, where we basically add getters for all fields.
-      compiledClass.createImplicitAccessors(this);
+      classBuilder.createImplicitAccessors(this);
     }
 
     List<Command> commands = <Command>[
         const NewMap(MapId.methods),
         const NewMap(MapId.classes),
         const NewMap(MapId.constants),
     ];
 
     List<Function> deferredActions = <Function>[];
 
     functions.forEach((f) => pushNewFunction(f, commands, deferredActions));
 
     int changes = 0;
 
-    for (CompiledClass compiledClass in classes) {
-      ClassElement element = compiledClass.element;
+    for (FletchClassBuilder classBuilder in classes) {
+      ClassElement element = classBuilder.element;
       if (builtinClasses.contains(element)) {
         int nameId = context.getSymbolId(element.name);
-        commands.add(new PushBuiltinClass(nameId, compiledClass.fields));
+        commands.add(new PushBuiltinClass(nameId, classBuilder.fields));
       } else {
-        commands.add(new PushNewClass(compiledClass.fields));
+        commands.add(new PushNewClass(classBuilder.fields));
       }
 
       commands.add(const Dup());
-      commands.add(new PopToMap(MapId.classes, compiledClass.id));
+      commands.add(new PopToMap(MapId.classes, classBuilder.id));
 
-      Map<int, int> methodTable = compiledClass.computeMethodTable(this);
+      Map<int, int> methodTable = classBuilder.computeMethodTable(this);
       methodTable.forEach((int selector, int methodId) {
         commands.add(new PushNewInteger(selector));
         commands.add(new PushFromMap(MapId.methods, methodId));
       });
       commands.add(new ChangeMethodTable(methodTable.length));
 
       changes++;
     }
 
     context.forEachStatic((element, index) {
-      CompiledFunction initializer = lazyFieldInitializers[element];
+      FletchFunctionBuilder initializer = lazyFieldInitializers[element];
       if (initializer != null) {
         commands.add(new PushFromMap(MapId.methods, initializer.methodId));
         commands.add(const PushNewInitializer());
       } else {
         commands.add(const PushNull());
       }
     });
     commands.add(new ChangeStatics(context.staticIndices.length));
     changes++;
 
@@ skipping 23 matching lines @@
         ListConstantValue value = constant;
         addList(constant.entries);
       } else if (constant.isMap) {
         MapConstantValue value = constant;
         addList(value.keys);
         addList(value.values);
         commands.add(new PushConstantMap(value.length * 2));
       } else if (constant.isConstructedObject) {
         ConstructedConstantValue value = constant;
         ClassElement classElement = value.type.element;
-        CompiledClass compiledClass = compiledClasses[classElement];
+        FletchClassBuilder classBuilder = classBuilderes[classElement];
         for (ConstantValue field in value.fields.values) {
           int fieldId = context.compiledConstants[field];
           commands.add(new PushFromMap(MapId.constants, fieldId));
         }
         commands
-            ..add(new PushFromMap(MapId.classes, compiledClass.id))
+            ..add(new PushFromMap(MapId.classes, classBuilder.id))
             ..add(const PushNewInstance());
       } else if (constant is FletchClassInstanceConstant) {
         commands
             ..add(new PushFromMap(MapId.classes, constant.classId))
             ..add(const PushNewInstance());
       } else {
         throw "Unsupported constant: ${constant.toStructuredString()}";
       }
       commands.add(new PopToMap(MapId.constants, id));
     });
 
-    for (CompiledClass compiledClass in classes) {
-      CompiledClass superclass = compiledClass.superclass;
+    for (FletchClassBuilder classBuilder in classes) {
+      FletchClassBuilder superclass = classBuilder.superclass;
       if (superclass == null) continue;
-      commands.add(new PushFromMap(MapId.classes, compiledClass.id));
+      commands.add(new PushFromMap(MapId.classes, classBuilder.id));
       commands.add(new PushFromMap(MapId.classes, superclass.id));
       commands.add(const ChangeSuperClass());
       changes++;
     }
 
     for (Function action in deferredActions) {
       action();
       changes++;
     }
 
     commands.add(new CommitChanges(changes));
 
     commands.add(const PushNewInteger(0));
 
     commands.add(new PushFromMap(
         MapId.methods,
-        compiledFunctions[fletchSystemEntry].methodId));
+        functionBuilders[fletchSystemEntry].methodId));
 
     this.commands = commands;
 
     return 0;
   }
 
   void pushNewFunction(
-      CompiledFunction compiledFunction,
+      FletchFunctionBuilder functionBuilder,
       List<Command> commands,
       List<Function> deferredActions) {
-    int arity = compiledFunction.builder.functionArity;
-    int constantCount = compiledFunction.constants.length;
-    int methodId = compiledFunction.methodId;
+    int arity = functionBuilder.builder.functionArity;
+    int constantCount = functionBuilder.constants.length;
+    int methodId = functionBuilder.methodId;
 
-    assert(functions[methodId] == compiledFunction);
-    assert(compiledFunction.builder.bytecodes.isNotEmpty);
+    assert(functions[methodId] == functionBuilder);
+    assert(functionBuilder.builder.bytecodes.isNotEmpty);
 
-    compiledFunction.constants.forEach((constant, int index) {
+    functionBuilder.constants.forEach((constant, int index) {
       if (constant is ConstantValue) {
         if (constant is FletchFunctionConstant) {
           commands.add(const PushNull());
           deferredActions.add(() {
             commands
                 ..add(new PushFromMap(MapId.methods, methodId))
                 ..add(new PushFromMap(MapId.methods, constant.methodId))
                 ..add(new ChangeMethodLiteral(index));
           });
         } else if (constant is FletchClassConstant) {
@@ skipping 19 matching lines @@
         }
       } else {
         throw "Unsupported constant: ${constant.runtimeType}";
       }
     });
 
     commands.add(
         new PushNewFunction(
             arity,
             constantCount,
-            compiledFunction.builder.bytecodes,
-            compiledFunction.builder.catchRanges));
+            functionBuilder.builder.bytecodes,
+            functionBuilder.builder.catchRanges));
 
     commands.add(new PopToMap(MapId.methods, methodId));
   }
 
   bool registerDeferredLoading(Spannable node, Registry registry) {
     compiler.reportWarning(
         node,
         MessageKind.GENERIC,
         {'text': "Deferred loading is not supported."});
     return false;
@@ skipping 72 matching lines @@
     return element;
   }
 
   int compileLazyFieldInitializer(FieldElement field, Registry registry) {
     int index = context.getStaticFieldIndex(field, null);
 
     if (field.initializer == null) return index;
 
     if (lazyFieldInitializers.containsKey(field)) return index;
 
-    CompiledFunction compiledFunction = new CompiledFunction.lazyInit(
+    FletchFunctionBuilder functionBuilder = new FletchFunctionBuilder.lazyInit(
         functions.length,
         "${field.name} lazy initializer",
         field,
         0);
-    functions.add(compiledFunction);
-    lazyFieldInitializers[field] = compiledFunction;
+    functions.add(functionBuilder);
+    lazyFieldInitializers[field] = functionBuilder;
 
     TreeElements elements = field.resolvedAst.elements;
 
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         field,
         elements);
 
     LazyFieldInitializerCodegen codegen = new LazyFieldInitializerCodegen(
-        compiledFunction,
+        functionBuilder,
         context,
         elements,
         registry,
         closureEnvironment,
         field);
 
     codegen.compile();
 
     return index;
   }
 
-  CompiledFunction compileConstructor(ConstructorElement constructor,
+  FletchFunctionBuilder compileConstructor(ConstructorElement constructor,
                                       Registry registry) {
     assert(constructor.isDeclaration);
-    CompiledFunction compiledFunction = constructors[constructor];
-    if (compiledFunction != null) return compiledFunction;
+    FletchFunctionBuilder functionBuilder = constructors[constructor];
+    if (functionBuilder != null) return functionBuilder;
 
     ClassElement classElement = constructor.enclosingClass;
-    CompiledClass compiledClass = registerClassElement(classElement);
+    FletchClassBuilder classBuilder = registerClassElement(classElement);
 
     ConstructorElement implementation = constructor.implementation;
 
     if (compiler.verbose) {
       // TODO(johnniwinther): Use reportVerboseInfo once added.
       compiler.reportHint(
           constructor,
           MessageKind.GENERIC,
           {'text': 'Compiling constructor ${implementation.name}'});
     }
 
     TreeElements elements = implementation.resolvedAst.elements;
 
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         implementation,
         elements);
 
-    compiledFunction = new CompiledFunction(
+    functionBuilder = new FletchFunctionBuilder(
         functions.length,
         implementation.name,
         implementation,
         implementation.functionSignature,
         null,
-        kind: CompiledFunctionKind.INITIALIZER_LIST);
-    functions.add(compiledFunction);
-    constructors[constructor] = compiledFunction;
+        kind: FletchFunctionBuilderKind.INITIALIZER_LIST);
+    functions.add(functionBuilder);
+    constructors[constructor] = functionBuilder;
 
     ConstructorCodegen codegen = new ConstructorCodegen(
-        compiledFunction,
+        functionBuilder,
         context,
         elements,
         registry,
         closureEnvironment,
         implementation,
-        compiledClass);
+        classBuilder);
 
     codegen.compile();
 
     if (compiler.verbose) {
-      compiler.log(compiledFunction.verboseToString());
+      compiler.log(functionBuilder.verboseToString());
     }
 
-    return compiledFunction;
+    return functionBuilder;
   }
 
   /**
    * Generate a getter for field [fieldIndex].
    */
   int makeGetter(int fieldIndex) {
     return getters.putIfAbsent(fieldIndex, () {
-      CompiledFunction stub = new CompiledFunction.accessor(
+      FletchFunctionBuilder stub = new FletchFunctionBuilder.accessor(
           functions.length,
           false);
       functions.add(stub);
       stub.builder
           ..loadParameter(0)
           ..loadField(fieldIndex)
           ..ret()
           ..methodEnd();
       return stub.methodId;
     });
   }
 
   /**
    * Generate a setter for field [fieldIndex].
    */
   int makeSetter(int fieldIndex) {
     return setters.putIfAbsent(fieldIndex, () {
-      CompiledFunction stub = new CompiledFunction.accessor(
+      FletchFunctionBuilder stub = new FletchFunctionBuilder.accessor(
           functions.length,
           true);
       functions.add(stub);
       stub.builder
           ..loadParameter(0)
           ..loadParameter(1)
           ..storeField(fieldIndex)
           // Top is at this point the rhs argument, thus the return value.
           ..ret()
           ..methodEnd();
       return stub.methodId;
     });
   }
 
   void generateUnimplementedError(
       Spannable spannable,
       String reason,
-      CompiledFunction function) {
+      FletchFunctionBuilder function) {
     compiler.reportError(
         spannable, MessageKind.GENERIC, {'text': reason});
     var constString = constantSystem.createString(
         new DartString.literal(reason));
     context.markConstantUsed(constString);
     function
         ..builder.loadConst(function.allocateConstant(constString))
         ..builder.emitThrow();
   }
 
   void forgetElement(Element element) {
-    CompiledFunction compiledFunction = compiledFunctions[element];
-    if (compiledFunction == null) return;
-    compiledFunction.reuse();
+    FletchFunctionBuilder functionBuilder = functionBuilders[element];
+    if (functionBuilder == null) return;
+    functionBuilder.reuse();
   }
 }