Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/fletch_function_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_function;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
 import 'package:compiler/src/constants/expressions.dart' show
     ConstantExpression;
 
 import 'package:compiler/src/tree/tree.dart' show
     Expression;
 
 import 'package:compiler/src/elements/elements.dart';
 
 import 'fletch_constants.dart' show
     FletchFunctionConstant,
     FletchClassConstant;
 
 import 'package:compiler/src/universe/universe.dart'
     show Selector;
 
 import '../bytecodes.dart' show
     Bytecode;
 
-import 'compiled_class.dart' show
-    CompiledClass;
+import 'fletch_class_builder.dart' show
+    FletchClassBuilder;
 
 import 'fletch_context.dart';
 import 'bytecode_builder.dart';
 import 'debug_info.dart';
 
-enum CompiledFunctionKind {
+enum FletchFunctionBuilderKind {
   NORMAL,
   LAZY_FIELD_INITIALIZER,
   INITIALIZER_LIST,
   PARAMETER_STUB,
   ACCESSOR
 }
 
-class CompiledFunction {
+class FletchFunctionBuilder {
   final BytecodeBuilder builder;
   final int methodId;
 
   /**
-   * The signature of the CompiledFunction.
+   * The signature of the FletchFunctionBuilder.
    *
    * Som compiled functions does not have a signature (for example, generated
    * accessors).
    */
   final FunctionSignature signature;
 
   /**
    * If the functions is an instance member, [memberOf] is set to the compiled
    * class.
    *
    * If [memberOf] is set, the compiled function takes an 'this' argument in
    * addition to that of [signature].
    */
-  final CompiledClass memberOf;
+  final FletchClassBuilder memberOf;
   final String name;
   final Element element;
   final Map<ConstantValue, int> constants = <ConstantValue, int>{};
   final Map<int, ConstantValue> functionConstantValues = <int, ConstantValue>{};
   final Map<int, ConstantValue> classConstantValues = <int, ConstantValue>{};
-  final Map<Selector, CompiledFunction> parameterMappings =
-      <Selector, CompiledFunction>{};
+  final Map<Selector, FletchFunctionBuilder> parameterMappings =
+      <Selector, FletchFunctionBuilder>{};
   final int arity;
-  final CompiledFunctionKind kind;
+  final FletchFunctionBuilderKind kind;
 
   DebugInfo debugInfo;
 
-  CompiledFunction(this.methodId,
+  FletchFunctionBuilder(this.methodId,
                    this.name,
                    this.element,
                    FunctionSignature signature,
-                   CompiledClass memberOf,
-                   {this.kind: CompiledFunctionKind.NORMAL})
+                   FletchClassBuilder memberOf,
+                   {this.kind: FletchFunctionBuilderKind.NORMAL})
       : this.signature = signature,
         this.memberOf = memberOf,
         arity = signature.parameterCount + (memberOf != null ? 1 : 0),
         builder = new BytecodeBuilder(
           signature.parameterCount + (memberOf != null ? 1 : 0));
 
-  CompiledFunction.normal(this.methodId, int argumentCount)
+  FletchFunctionBuilder.normal(this.methodId, int argumentCount)
       : arity = argumentCount,
         builder = new BytecodeBuilder(argumentCount),
-        kind = CompiledFunctionKind.NORMAL;
+        kind = FletchFunctionBuilderKind.NORMAL;
 
-  CompiledFunction.lazyInit(this.methodId,
+  FletchFunctionBuilder.lazyInit(this.methodId,
                             this.name,
                             this.element,
                             int argumentCount)
       : arity = argumentCount,
         builder = new BytecodeBuilder(argumentCount),
-        kind = CompiledFunctionKind.LAZY_FIELD_INITIALIZER;
+        kind = FletchFunctionBuilderKind.LAZY_FIELD_INITIALIZER;
 
-  CompiledFunction.parameterStub(this.methodId, int argumentCount)
+  FletchFunctionBuilder.parameterStub(this.methodId, int argumentCount)
       : arity = argumentCount,
         builder = new BytecodeBuilder(argumentCount),
-        kind = CompiledFunctionKind.PARAMETER_STUB;
+        kind = FletchFunctionBuilderKind.PARAMETER_STUB;
 
-  CompiledFunction.accessor(this.methodId, bool setter)
+  FletchFunctionBuilder.accessor(this.methodId, bool setter)
       : arity = setter ? 2 : 1,
         builder = new BytecodeBuilder(setter ? 2 : 1),
-        kind = CompiledFunctionKind.ACCESSOR;
+        kind = FletchFunctionBuilderKind.ACCESSOR;
 
   void reuse() {
     builder.reuse();
     constants.clear();
     functionConstantValues.clear();
     classConstantValues.clear();
   }
 
   bool get hasThisArgument => memberOf != null;
 
   bool get isLazyFieldInitializer {
-    return kind == CompiledFunctionKind.LAZY_FIELD_INITIALIZER;
+    return kind == FletchFunctionBuilderKind.LAZY_FIELD_INITIALIZER;
   }
 
   bool get isInitializerList {
-    return kind == CompiledFunctionKind.INITIALIZER_LIST;
+    return kind == FletchFunctionBuilderKind.INITIALIZER_LIST;
   }
 
   bool get isAccessor {
-    return kind == CompiledFunctionKind.ACCESSOR;
+    return kind == FletchFunctionBuilderKind.ACCESSOR;
   }
 
   bool get isParameterStub {
-    return kind == CompiledFunctionKind.PARAMETER_STUB;
+    return kind == FletchFunctionBuilderKind.PARAMETER_STUB;
   }
 
   bool get isConstructor => element != null && element.isConstructor;
 
   int allocateConstant(ConstantValue constant) {
     if (constant == null) throw "bad constant";
     return constants.putIfAbsent(constant, () => constants.length);
   }
 
   int allocateConstantFromFunction(int methodId) {
     FletchFunctionConstant constant =
         functionConstantValues.putIfAbsent(
             methodId, () => new FletchFunctionConstant(methodId));
     return allocateConstant(constant);
   }
 
   int allocateConstantFromClass(int classId) {
     FletchClassConstant constant =
         classConstantValues.putIfAbsent(
             classId, () => new FletchClassConstant(classId));
     return allocateConstant(constant);
   }
 
   // TODO(ajohnsen): Remove this function when usage is avoided in
   // FletchBackend.
-  void copyFrom(CompiledFunction function) {
+  void copyFrom(FletchFunctionBuilder function) {
     builder.bytecodes.addAll(function.builder.bytecodes);
     builder.catchRanges.addAll(function.builder.catchRanges);
     constants.addAll(function.constants);
     functionConstantValues.addAll(function.functionConstantValues);
     classConstantValues.addAll(function.classConstantValues);
   }
 
   bool matchesSelector(Selector selector) {
     if (!canBeCalledAs(selector)) return false;
     if (selector.namedArguments.length != signature.optionalParameterCount) {
@@ skipping 37 matching lines @@
         if (!nameSet.contains(name)) return false;
         // TODO(5213): By removing from the set we are checking
         // that we are not passing the name twice. We should have this
         // check in the resolver also.
         nameSet.remove(name);
       }
       return true;
     }
   }
 
-  CompiledFunction createParameterMappingFor(
+  FletchFunctionBuilder createParameterMappingFor(
       Selector selector,
       FletchContext context) {
     return parameterMappings.putIfAbsent(selector, () {
       assert(canBeCalledAs(selector));
       int arity = selector.argumentCount;
       if (hasThisArgument) arity++;
 
-      CompiledFunction compiledFunction = new CompiledFunction.parameterStub(
-          context.backend.functions.length,
-          arity);
-      context.backend.functions.add(compiledFunction);
+      FletchFunctionBuilder functionBuilder =
+          new FletchFunctionBuilder.parameterStub(
+              context.backend.functions.length,
+              arity);
+      context.backend.functions.add(functionBuilder);
 
-      BytecodeBuilder builder = compiledFunction.builder;
+      BytecodeBuilder builder = functionBuilder.builder;
 
       void loadInitializerOrNull(ParameterElement parameter) {
         Expression initializer = parameter.initializer;
         if (initializer != null) {
           ConstantExpression expression = context.compileConstant(
               initializer,
               parameter.memberContext.resolvedAst.elements,
               isConst: true);
-          int constId = compiledFunction.allocateConstant(
+          int constId = functionBuilder.allocateConstant(
               context.getConstantValue(expression));
           builder.loadConst(constId);
         } else {
           builder.loadLiteralNull();
         }
       }
 
       // Load this.
       if (hasThisArgument) builder.loadParameter(0);
 
@@ skipping 17 matching lines @@
             loadInitializerOrNull(parameter);
           }
         }
         index++;
       });
 
       // TODO(ajohnsen): We have to be extra careful when overriding a
       // method that takes optional arguments. We really should
       // enumerate all the stubs in the superclasses and make sure
       // they're overridden.
-      int constId = compiledFunction.allocateConstantFromFunction(methodId);
+      int constId = functionBuilder.allocateConstantFromFunction(methodId);
       builder
           ..invokeStatic(constId, index)
           ..ret()
           ..methodEnd();
 
       if (memberOf != null) {
         int fletchSelector = context.toFletchSelector(selector);
-        memberOf.addToMethodTable(fletchSelector, compiledFunction);
+        memberOf.addToMethodTable(fletchSelector, functionBuilder);
       }
 
-      return compiledFunction;
+      return functionBuilder;
     });
   }
 
   String verboseToString() {
     StringBuffer sb = new StringBuffer();
 
     sb.writeln("Method $methodId, Arity=${builder.functionArity}");
     sb.writeln("Constants:");
     constants.forEach((constant, int index) {
       if (constant is ConstantValue) {
         constant = constant.toStructuredString();
       }
       sb.writeln("  #$index: $constant");
     });
 
     sb.writeln("Bytecodes:");
     int offset = 0;
     for (Bytecode bytecode in builder.bytecodes) {
       sb.writeln("  $offset: $bytecode");
       offset += bytecode.size;
     }
 
     return '$sb';
   }
 }