Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/incremental/library_updater.dart

 // Copyright (c) 2014, the Dart 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 file.
 
 library fletchc_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 42 matching lines @@
     FunctionExpression,
     LibraryTag,
     NodeList,
     Part,
     StringNode,
     unparse;
 
 import '../src/fletch_backend.dart' show
     FletchBackend;
 
-import '../src/compiled_class.dart' show
-    CompiledClass;
+import '../src/fletch_class_builder.dart' show
+    FletchClassBuilder;
 
 import '../commands.dart' show
     Command,
     MapId;
 
 import '../commands.dart' as commands_lib;
 
 import 'package:compiler/src/util/util.dart' show
     Link,
     LinkBuilder;
@@ skipping 16 matching lines @@
     TagState;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 import 'fletchc_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalCompiler;
 
-import '../src/compiled_function.dart' show
-    CompiledFunction;
+import '../src/fletch_function_builder.dart' show
+    FletchFunctionBuilder;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
     PartialElement after);
 
 class FailedUpdate {
   /// Either an [Element] or a [Difference].
@@ skipping 742 matching lines @@
         updates.add(new commands_lib.PopToMap(MapId.constants, id));
       }
     });
 
     for (Function action in deferredActions) {
       action();
       changes++;
     }
 
     for (ClassElementX element in _classesWithSchemaChanges) {
-      CompiledClass compiledClass = backend.compiledClasses[element];
-      int id = compiledClass.id;
+      FletchClassBuilder classBuilder = backend.classBuilders[element];
+      int id = classBuilder.id;
       updates.add(new commands_lib.PushFromMap(MapId.classes, id));
 
-      compiledClass.createImplicitAccessors(backend);
-      Map<int, int> methodTable = compiledClass.computeMethodTable(backend);
+      classBuilder.createImplicitAccessors(backend);
+      Map<int, int> methodTable = classBuilder.computeMethodTable(backend);
 
       methodTable.forEach((int selector, int methodId) {
         updates.add(new commands_lib.PushNewInteger(selector));
         updates.add(new commands_lib.PushFromMap(MapId.methods, methodId));
       });
 
       updates.add(new commands_lib.ChangeMethodTable(methodTable.length));
       changes++;
     }
 
     for (ClassElementX element in _classesWithSchemaChanges) {
       computeSchemaChange(element, beforeFields[element], updates);
       changes++;
     }
 
     updates.add(new commands_lib.CommitChanges(changes));
 
     return updates;
   }
 
   void computeFieldUpdateFletch(FieldElementX element, List<Command> commands) {
     throw new IncrementalCompilationFailed("Not implemented yet.");
   }
 
   void computeMethodUpdateFletch(Element element, List<Command> commands) {
-    CompiledFunction function = lookupCompiledFunction(element);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(element);
     backend.pushNewFunction(function, commands, deferredActions);
     if (element == backend.context.compiler.mainFunction) {
       deferredActions.add(() {
-        CompiledFunction callMain =
-            lookupCompiledFunction(
+        FletchFunctionBuilder callMain =
+            lookupFletchFunctionBuilder(
                 backend.fletchSystemLibrary.findLocal('callMain'));
         commands.add(
             new commands_lib.PushFromMap(MapId.methods, callMain.methodId));
         commands.add(
             new commands_lib.PushFromMap(MapId.methods, function.methodId));
         commands.add(new commands_lib.ChangeMethodLiteral(0));
       });
     }
   }
 
   void computeSchemaChange(ClassElementX element,
                            Map<FieldElementX, int> beforeFields,
                            List<Command> commands) {
-    CompiledClass compiledClass = backend.compiledClasses[element];
+    FletchClassBuilder classBuilder = backend.classBuilders[element];
 
     // Collect the list of fields as they should exist after the transformation.
     List<FieldElementX> afterFields = [];
     forEachField(element, (field) {
       afterFields.add(field);
     });
 
     // First, we push all the classes we want to change the schema of. This
     // includes all subclasses.
     int numberOfClasses = 0;
     Queue<ClassElementX> workQueue = new Queue<ClassElementX>()..add(element);
     while (workQueue.isNotEmpty) {
       ClassElementX current = workQueue.removeFirst();
-      int id = backend.compiledClasses[current].id;
+      int id = backend.classBuilders[current].id;
       commands.add(new commands_lib.PushFromMap(MapId.classes, id));
       numberOfClasses++;
       // Add all subclasses that aren't schema change target themselves to
       // the work queue.
       for (ClassElementX subclass in backend.directSubclasses[current]) {
         if (!_classesWithSchemaChanges.contains(subclass)) {
           workQueue.add(subclass);
         }
       }
     }
@@ skipping 205 matching lines @@
 
     throw new IncrementalCompilationFailed("Not implemented yet.");
   }
 }
 
 class RemovedFieldUpdate extends RemovalUpdate with FletchFeatures {
   final FieldElementX element;
 
   bool wasStateCaptured = false;
 
-  CompiledClass beforeCompiledClass;
+  FletchClassBuilder beforeFletchClassBuilder;
   Map<FieldElement, int> beforeFields;
 
   RemovedFieldUpdate(Compiler compiler, this.element)
       : super(compiler);
 
   PartialFieldList get before => element.declarationSite;
 
   PartialFieldList get after => null;
 
   void captureState() {
@@ skipping 203 matching lines @@
   return element is ElementX ? element.declarationSite : null;
 }
 
 abstract class FletchFeatures {
   Compiler get compiler;
 
   FletchBackend get backend => compiler.backend;
 
   EnqueueTask get enqueuer => compiler.enqueuer;
 
-  CompiledFunction lookupCompiledFunction(FunctionElement function) {
-    return backend.compiledFunctions[function];
+  FletchFunctionBuilder lookupFletchFunctionBuilder(FunctionElement function) {
+    return backend.functionBuilders[function];
   }
 }
 
 // TODO(ahe): Remove this method.
 NO_WARN(x) => x;