Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/fletch_class_builder.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.compiled_class;
+library fletchc.fletch_class_builder;
 
 import 'package:compiler/src/dart_types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/universe/universe.dart';
 
-import 'compiled_function.dart' show
-    CompiledFunction;
+import 'fletch_function_builder.dart' show
+    FletchFunctionBuilder;
 
 import 'fletch_backend.dart';
 
-class CompiledClass {
+class FletchClassBuilder {
   final int id;
   final ClassElement element;
-  final CompiledClass superclass;
+  final FletchClassBuilder superclass;
 
   // The extra fields are synthetic fields not represented in any Dart source
   // code. They are used for the synthetic closure classes that are introduced
   // behind the scenes.
   final int extraFields;
 
   // TODO(kasperl): Hide these tables and go through a proper API to define
   // and lookup methods.
   final Map<int, int> implicitAccessorTable = <int, int>{};
-  final Map<int, CompiledFunction> methodTable = <int, CompiledFunction>{};
+  final Map<int, FletchFunctionBuilder> methodTable =
+      <int, FletchFunctionBuilder>{};
 
-  CompiledClass(this.id, this.element, this.superclass, {this.extraFields: 0});
+  FletchClassBuilder(
+      this.id, this.element, this.superclass, {this.extraFields: 0});
 
   /**
    * Returns the number of instance fields of all the super classes of this
    * class.
    *
    * If this class has no super class (if it's Object), 0 is returned.
    */
   int get superclassFields => hasSuperClass ? superclass.fields : 0;
 
   bool get hasSuperClass => superclass != null;
 
   int get fields {
     int count = superclassFields + extraFields;
     if (element != null) {
       // TODO(kasperl): Once we change compiled class to be immutable, we
       // should cache the field count.
       element.implementation.forEachInstanceField((_, __) { count++; });
     }
     return count;
   }
 
-  void addToMethodTable(int selector, CompiledFunction compiledFunction) {
-    methodTable[selector] = compiledFunction;
+  void addToMethodTable(int selector, FletchFunctionBuilder functionBuilder) {
+    methodTable[selector] = functionBuilder;
   }
 
   // Add a selector for is-tests. The selector is only to be hit with the
   // InvokeTest bytecode, as the function is not guraranteed to be valid.
   void addIsSelector(int selector) {
     // TODO(ajohnsen): 'null' is a placeholder. Generate dummy function?
     methodTable[selector] = null;
   }
 
   // The method table for a class is a mapping from Fletch's integer
   // selectors to method ids. It contains all methods defined for a
   // class including the implicit accessors.
   Map<int, int> computeMethodTable(FletchBackend backend) {
     Map<int, int> result = <int, int>{};
     List<int> selectors = implicitAccessorTable.keys.toList()
         ..addAll(methodTable.keys)
         ..sort();
     for (int selector in selectors) {
       if (methodTable.containsKey(selector)) {
-        CompiledFunction function = methodTable[selector];
+        FletchFunctionBuilder function = methodTable[selector];
         result[selector] = function == null ? 0 : function.methodId;
       } else {
         result[selector] = implicitAccessorTable[selector];
       }
     }
     return result;
   }
 
   void createImplicitAccessors(FletchBackend backend) {
     implicitAccessorTable.clear();
@@ skipping 15 matching lines @@
       }
 
       fieldIndex++;
     });
   }
 
   void createIsEntries(FletchBackend backend) {
     if (element == null) return;
 
     Set superclasses = new Set();
-    for (CompiledClass current = superclass;
+    for (FletchClassBuilder current = superclass;
          current != null;
          current = current.superclass) {
       superclasses.add(current.element);
     }
 
     void createFor(ClassElement classElement) {
       if (superclasses.contains(classElement)) return;
       int fletchSelector = backend.context.toFletchIsSelector(classElement);
       addIsSelector(fletchSelector);
     }
 
     // Create for the current element.
     createFor(element);
 
     // Add all types related to 'implements'.
     for (InterfaceType interfaceType in element.interfaces) {
       createFor(interfaceType.element);
       for (DartType type in interfaceType.element.allSupertypes) {
         createFor(type.element);
       }
     }
   }
 
   void createIsFunctionEntry(FletchBackend backend) {
     int fletchSelector = backend.context.toFletchIsSelector(
         backend.compiler.functionClass);
     addIsSelector(fletchSelector);
   }
 
-  String toString() => "CompiledClass(${element.name}, $id)";
+  String toString() => "FletchClassBuilder(${element.name}, $id)";
 }