Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/debug_info_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.debug_info_constructor_codegen;
 
 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/dart2jslib.dart' show
     Registry;
 
 import 'package:compiler/src/dart_types.dart' show
     DartType;
 
 import 'package:compiler/src/util/util.dart' show
     Spannable;
 
 import 'bytecode_builder.dart';
 import 'closure_environment.dart';
 import 'codegen_visitor.dart';
 
-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 'fletch_backend.dart';
 import 'fletch_context.dart';
 import 'constructor_codegen.dart';
 import 'lazy_field_initializer_codegen.dart';
 import 'debug_info_lazy_field_initializer_codegen.dart';
 
 class DebugInfoConstructorCodegen extends ConstructorCodegen {
   final FletchCompiler compiler;
 
   // Regenerate the bytecode in a fresh buffer separately from the compiled
   // function. If we did not create a separate buffer, the bytecode would
   // be appended to the compiled function builder and we would get a compiled
   // function with incorrect bytecode.
   final BytecodeBuilder debugBuilder;
 
-  DebugInfoConstructorCodegen(CompiledFunction compiledFunction,
+  DebugInfoConstructorCodegen(FletchFunctionBuilder functionBuilder,
                               FletchContext context,
                               TreeElements elements,
                               Registry registry,
                               ClosureEnvironment closureEnvironment,
                               ConstructorElement constructor,
-                              CompiledClass compiledClass,
+                              FletchClassBuilder classBuilder,
                               this.compiler)
-      : debugBuilder = new BytecodeBuilder(compiledFunction.arity),
-        super(compiledFunction, context, elements, registry,
-              closureEnvironment, constructor, compiledClass);
+      : debugBuilder = new BytecodeBuilder(functionBuilder.arity),
+        super(functionBuilder, context, elements, registry,
+              closureEnvironment, constructor, classBuilder);
 
   BytecodeBuilder get builder => debugBuilder;
 
   LazyFieldInitializerCodegen lazyFieldInitializerCodegenFor(
-      CompiledFunction function,
+      FletchFunctionBuilder function,
       FieldElement field) {
     TreeElements elements = field.resolvedAst.elements;
     return new DebugInfoLazyFieldInitializerCodegen(
         function,
         context,
         elements,
         null,
         context.backend.createClosureEnvironment(field, elements),
         field,
         compiler,
         builder);
   }
 
   void recordDebugInfo(Node node) {
-    compiledFunction.debugInfo.addLocation(compiler, builder.byteSize, node);
+    functionBuilder.debugInfo.addLocation(compiler, builder.byteSize, node);
   }
 
   void pushVariableDeclaration(LocalValue value) {
     super.pushVariableDeclaration(value);
-    compiledFunction.debugInfo.pushScope(builder.byteSize, value);
+    functionBuilder.debugInfo.pushScope(builder.byteSize, value);
   }
 
   void popVariableDeclaration(Element element) {
     super.popVariableDeclaration(element);
-    compiledFunction.debugInfo.popScope(builder.byteSize);
+    functionBuilder.debugInfo.popScope(builder.byteSize);
   }
 
   void registerDynamicInvocation(Selector selector) { }
   void registerDynamicGetter(Selector selector) { }
   void registerDynamicSetter(Selector selector) { }
   void registerStaticInvocation(FunctionElement function) { }
   void registerInstantiatedClass(ClassElement klass) { }
 
   void doFieldInitializerSet(Send node, FieldElement field) {
     recordDebugInfo(node);
@@ skipping 66 matching lines @@
   void visitForValue(Node node) {
     recordDebugInfo(node);
     super.visitForValue(node);
   }
 
   void visitForEffect(Node node) {
     recordDebugInfo(node);
     super.visitForEffect(node);
   }
 }