Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/debug_info_lazy_field_initializer_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_lazy_field_initializer_codegen;
 
 import 'package:compiler/src/dart2jslib.dart' show
     MessageKind,
     Registry;
 
 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/dart_types.dart' show
     DartType;
 
 import 'package:compiler/src/util/util.dart' show
     Spannable;
 
 import 'fletch_context.dart';
 
-import 'compiled_function.dart' show
-    CompiledFunction;
+import 'fletch_function_builder.dart' show
+    FletchFunctionBuilder;
 
 import 'closure_environment.dart';
 import 'codegen_visitor.dart';
 import 'lazy_field_initializer_codegen.dart';
 
 class DebugInfoLazyFieldInitializerCodegen
     extends LazyFieldInitializerCodegen {
   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;
 
-  // TODO(ajohnsen): Consider creating a DebugCompiledFunction instead of only
+  // TODO(ajohnsen): Consider creating a DebugFletchFunctionBuilder instead of only

[ahe, 2015/06/09 09:14:56]

Long line.

[Anders Johnsen, 2015/06/09 10:15:41]

Done.

   // intercepting the BytecodeBuilder, or simply replace the BytecodeBuilder
-  // in the CompiledFunction.
-  DebugInfoLazyFieldInitializerCodegen(CompiledFunction compiledFunction,
+  // in the FletchFunctionBuilder.
+  DebugInfoLazyFieldInitializerCodegen(FletchFunctionBuilder functionBuilder,
                                        FletchContext context,
                                        TreeElements elements,
                                        Registry registry,
                                        ClosureEnvironment closureEnvironment,
                                        FieldElement field,
                                        this.compiler,
                                        [BytecodeBuilder builder])
       : debugBuilder = (builder == null)
-            ? new BytecodeBuilder(compiledFunction.arity)
+            ? new BytecodeBuilder(functionBuilder.arity)
             : builder,
-        super(compiledFunction, context, elements, registry,
+        super(functionBuilder, context, elements, registry,
               closureEnvironment, field);
 
   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);
   }
 }