Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/debug_info_function_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_function_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 'fletch_context.dart';
 import 'function_codegen.dart';
 
 class DebugInfoFunctionCodegen extends FunctionCodegen {
   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;
 
-  DebugInfoFunctionCodegen(CompiledFunction compiledFunction,
+  DebugInfoFunctionCodegen(FletchFunctionBuilder functionBuilder,
                            FletchContext context,
                            TreeElements elements,
                            Registry registry,
                            ClosureEnvironment closureEnvironment,
                            FunctionElement function,
                            this.compiler)
-      : debugBuilder = new BytecodeBuilder(compiledFunction.arity),
-        super(compiledFunction, context, elements, registry,
+      : debugBuilder = new BytecodeBuilder(functionBuilder.arity),
+        super(functionBuilder, context, elements, registry,
               closureEnvironment, function) {
-    if (compiledFunction.hasThisArgument) pushVariableDeclaration(thisValue);
+    if (functionBuilder.hasThisArgument) pushVariableDeclaration(thisValue);
   }
 
   BytecodeBuilder get builder => debugBuilder;
 
   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 callIsSelector(
       Node node,
@@ skipping 53 matching lines @@
   void visitForValue(Node node) {
     recordDebugInfo(node);
     super.visitForValue(node);
   }
 
   void visitForEffect(Node node) {
     recordDebugInfo(node);
     super.visitForEffect(node);
   }
 }