Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/src/codegen_visitor.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.codegen_visitor;
 
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 
 import 'package:compiler/src/resolution/operators.dart' show
     AssignmentOperator,
@@ skipping 22 matching lines @@
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/universe/universe.dart';
 import 'package:compiler/src/util/util.dart' show Spannable;
 import 'package:compiler/src/dart_types.dart';
 
 import 'fletch_context.dart';
 
 import 'fletch_backend.dart';
 
 import 'fletch_constants.dart' show
-    CompiledFunctionConstant,
+    FletchFunctionBuilderConstant,
     FletchClassConstant,
     FletchClassInstanceConstant;
 
 import '../bytecodes.dart' show
     Bytecode;
 
-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_selector.dart';
 
 import 'closure_environment.dart';
 
 enum VisitState {
   Value,
   Effect,
   Test,
 }
@@ skipping 96 matching lines @@
   final FletchContext context;
 
   final CodegenRegistry registry;
 
   final ClosureEnvironment closureEnvironment;
 
   final ExecutableElement element;
 
   final MemberElement member;
 
-  final CompiledFunction compiledFunction;
+  final FletchFunctionBuilder functionBuilder;
 
   final Map<Element, LocalValue> scope = <Element, LocalValue>{};
 
   final Map<Node, JumpInfo> jumpInfo = <Node, JumpInfo>{};
 
   // Stack of try blocks (inner-most first), in the lexical scope.
   Link<TryBlock> tryBlockStack = const Link<TryBlock>();
 
   VisitState visitState;
   BytecodeLabel trueLabel;
   BytecodeLabel falseLabel;
 
   // TODO(ajohnsen): Merge computation into constructor.
   // The slot at which 'this' is stored. In closures, this is overwritten.
   LocalValue thisValue;
 
   List<Element> blockLocals = <Element>[];
 
-  CodegenVisitor(CompiledFunction compiledFunction,
+  CodegenVisitor(FletchFunctionBuilder functionBuilder,
                  this.context,
                  TreeElements elements,
                  this.registry,
                  this.closureEnvironment,
                  this.element)
       : super(elements),
-        this.compiledFunction = compiledFunction,
+        this.functionBuilder = functionBuilder,
         thisValue = new UnboxedLocalValue(
-            -1 - compiledFunction.builder.functionArity,
+            -1 - functionBuilder.builder.functionArity,
             null);
 
-  BytecodeBuilder get builder => compiledFunction.builder;
+  BytecodeBuilder get builder => functionBuilder.builder;
 
   SemanticSendVisitor get sendVisitor => this;
   SemanticDeclarationVisitor get declVisitor => this;
 
   void compile();
 
   ConstantExpression compileConstant(
       Node node,
       {TreeElements elements,
        bool isConst}) {
     if (elements == null) elements = this.elements;
     return context.compileConstant(node, elements, isConst: isConst);
   }
 
   int allocateConstantFromNode(Node node, {TreeElements elements}) {
     ConstantExpression expression = compileConstant(
         node,
         elements: elements,
         isConst: false);
-    return compiledFunction.allocateConstant(
+    return functionBuilder.allocateConstant(
         context.getConstantValue(expression));
   }
 
   int allocateConstantClassInstance(int classId) {
     var constant = new FletchClassInstanceConstant(classId);
     context.markConstantUsed(constant);
-    return compiledFunction.allocateConstant(constant);
+    return functionBuilder.allocateConstant(constant);
   }
 
   int allocateStringConstant(String string) {
-    return compiledFunction.allocateConstant(
+    return functionBuilder.allocateConstant(
         context.backend.constantSystem.createString(
             new DartString.literal(string)));
   }
 
   ClosureInfo get closureInfo => closureEnvironment.closures[element];
 
   LocalValue createLocalValueFor(
       LocalElement element,
       [int slot]) {
     if (slot == null) slot = builder.stackSize;
@@ skipping 92 matching lines @@
     builder.dup();
     int constId = allocateConstantFromNode(caseMatch.expression);
     builder.loadConst(constId);
     // For debugging, ignore the equality checks in connection
     // with case matches by not associating the calls with
     // any node.
     invokeMethod(null, new Selector.binaryOperator('=='));
     builder.branchIfTrue(ifTrue);
   }
 
-  CompiledFunction requireCompiledFunction(FunctionElement element) {
+  FletchFunctionBuilder requireFletchFunctionBuilder(FunctionElement element) {
     registerStaticInvocation(element);
-    return context.backend.createCompiledFunction(element);
+    return context.backend.createFletchFunctionBuilder(element);
   }
 
   void doStaticFunctionInvoke(
       Node node,
-      CompiledFunction function,
+      FletchFunctionBuilder function,
       NodeList arguments,
       CallStructure callStructure,
       {bool factoryInvoke: false}) {
     if (function.hasThisArgument) loadThis();
     FunctionSignature signature = function.signature;
     int methodId;
     int arity;
     if (signature.hasOptionalParameters &&
         signature.optionalParametersAreNamed) {
       // TODO(ajohnsen): Don't use selectors.
       if (function.matchesSelector(callStructure.callSelector)) {
         methodId = function.methodId;
       } else if (function.canBeCalledAs(callStructure.callSelector)) {
         // TODO(ajohnsen): Inline parameter mapping?
-        CompiledFunction stub = function.createParameterMappingFor(
+        FletchFunctionBuilder stub = function.createParameterMappingFor(
             callStructure.callSelector, context);
         methodId = stub.methodId;
       } else {
         doUnresolved(function.name);
         return;
       }
       for (Node argument in arguments) {
         visitForValue(argument);
       }
       arity = callStructure.argumentCount;
     } else if (callStructure != null &&
                callStructure.namedArguments.isNotEmpty) {
       doUnresolved(function.name);
       return;
     } else {
       methodId = function.methodId;
       arity = loadPositionalArguments(arguments, signature, function.name);
     }
     if (function.hasThisArgument) arity++;
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     if (factoryInvoke) {
       invokeFactory(node, constId, arity);
     } else {
       invokeStatic(node, constId, arity);
     }
   }
 
   void loadThis() {
     thisValue.load(builder);
   }
@@ skipping 434 matching lines @@
     for (Node argument in arguments) {
       visitForValue(argument);
     }
     generateIdentical(node);
   }
 
   void handleStaticFunctionGet(
       Send node,
       MethodElement function,
       _) {
-    CompiledFunction compiledFunctionTarget = requireCompiledFunction(function);
-    CompiledClass compiledClass = context.backend.createTearoffClass(
-        compiledFunctionTarget);
-    assert(compiledClass.fields == 0);
-    int constId = allocateConstantClassInstance(compiledClass.id);
+    FletchFunctionBuilder functionBuilderTarget = requireFletchFunctionBuilder(
+        function);
+    FletchClassBuilder classBuilder = context.backend.createTearoffClass(
+        functionBuilderTarget);
+    assert(classBuilder.fields == 0);
+    int constId = allocateConstantClassInstance(classBuilder.id);
     builder.loadConst(constId);
     applyVisitState();
   }
 
   void doMainCall(Send node, NodeList arguments) {
     FunctionElement function = context.compiler.mainFunction;
     if (function.isErroneous) {
       doCompileError();
       return;
     }
     if (context.compiler.libraryLoader.libraries.any(checkCompileError)) return;
     registerStaticInvocation(function);
     // Load up to 'parameterCount' arguments, padding with nulls.
     int parameterCount = function.functionSignature.parameterCount;
     int argumentCount = 0;
     for (Node argument in arguments) {
       if (argumentCount == parameterCount) break;
       visitForValue(argument);
       argumentCount++;
     }
     for (int i = argumentCount; i < parameterCount; i++) {
       builder.loadLiteralNull();
     }
     int methodId = context.backend.functionMethodId(function);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     invokeStatic(node, constId, parameterCount);
   }
 
   void doStaticallyBoundInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure) {
     if (checkCompileError(element)) return;
     if (element.declaration == context.compiler.identicalFunction) {
       doIdenticalCall(node, arguments);
       return;
     }
     if (element.isExternal) {
       // Patch known functions directly.
       if (element == context.backend.fletchExternalInvokeMain) {
         doMainCall(node, arguments);
         return;
       } else if (element == context.backend.fletchExternalCoroutineChange) {
         for (Node argument in arguments) {
           visitForValue(argument);
         }
         builder.coroutineChange();
         return;
       }
       // TODO(ajohnsen): Define a known set of external functions we allow
       // calls to?
     }
-    CompiledFunction target = requireCompiledFunction(element);
+    FletchFunctionBuilder target = requireFletchFunctionBuilder(element);
     doStaticFunctionInvoke(node, target, arguments, callStructure);
   }
 
   void handleStaticFunctionInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticallyBoundInvoke(
         node, element.declaration, arguments, callStructure);
     applyVisitState();
   }
 
   void visitSuperMethodInvoke(
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticallyBoundInvoke(node, element, arguments, callStructure);
     applyVisitState();
   }
 
   void doSuperCall(Node node, FunctionElement function) {
     registerStaticInvocation(function);
     int arity = function.functionSignature.parameterCount + 1;
     int methodId = context.backend.functionMethodId(function);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     invokeStatic(node, constId, arity);
   }
 
   void visitSuperGetterGet(
       Send node,
       FunctionElement getter,
       _) {
     loadThis();
     doSuperCall(node, getter);
     applyVisitState();
   }
 
   void visitSuperMethodGet(
       Send node,
       MethodElement method,
       _) {
     loadThis();
-    CompiledFunction compiledFunctionTarget = requireCompiledFunction(method);
-    CompiledClass compiledClass = context.backend.createTearoffClass(
-        compiledFunctionTarget);
-    assert(compiledClass.fields == 1);
-    int constId = compiledFunction.allocateConstantFromClass(compiledClass.id);
-    builder.allocate(constId, compiledClass.fields);
+    FletchFunctionBuilder functionBuilderTarget = requireFletchFunctionBuilder(
+        method);
+    FletchClassBuilder classBuilder = context.backend.createTearoffClass(
+        functionBuilderTarget);
+    assert(classBuilder.fields == 1);
+    int constId = functionBuilder.allocateConstantFromClass(classBuilder.id);
+    builder.allocate(constId, classBuilder.fields);
     applyVisitState();
   }
 
   void visitSuperSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       _) {
     loadThis();
     visitForValue(rhs);
@@ skipping 108 matching lines @@
       UnaryOperator operator,
       FunctionElement function,
       _) {
     loadThis();
     doSuperCall(node, function);
     applyVisitState();
   }
 
   int computeFieldIndex(FieldElement field) {
     ClassElement classElement = field.enclosingClass;
-    // We know the enclosing class is compiled, so we can use the CompiledClass
-    // as an optimization for getting the number of super fields, thus we only
-    // have to iterate the fields of the enclosing class.
-    CompiledClass compiledClass = context.backend.registerClassElement(
+    // We know the enclosing class is compiled, so we can use the
+    // FletchClassBuilder as an optimization for getting the number of super
+    // fields, thus we only have to iterate the fields of the enclosing class.
+    FletchClassBuilder classBuilder = context.backend.registerClassElement(
         classElement);
     int i = 0;
     int fieldIndex;
     classElement.implementation.forEachInstanceField((_, FieldElement member) {
       if (member == field) {
         assert(fieldIndex == null);
         fieldIndex = i;
       }
       i++;
     });
     assert(fieldIndex != null);
-    fieldIndex += compiledClass.superclassFields;
+    fieldIndex += classBuilder.superclassFields;
     return fieldIndex;
   }
 
   void visitSuperFieldGet(
       Send node,
       FieldElement field,
       _) {
     loadThis();
     builder.loadField(computeFieldIndex(field));
     applyVisitState();
@@ skipping 762 matching lines @@
     }
     builder.pop();
   }
 
   void callConstructor(Node node,
                        ConstructorElement constructor,
                        NodeList arguments,
                        CallStructure callStructure) {
     registerStaticInvocation(constructor);
     registerInstantiatedClass(constructor.enclosingClass);
-    CompiledFunction compiledFunction = context.backend.compileConstructor(
+    FletchFunctionBuilder functionBuilder = context.backend.compileConstructor(
         constructor,
         registry);
     doStaticFunctionInvoke(
-        node, compiledFunction, arguments, callStructure);
+        node, functionBuilder, arguments, callStructure);
   }
 
   void doConstConstructorInvoke(ConstantExpression constant) {
     var value = context.getConstantValue(constant);
     context.markConstantUsed(value);
-    int constId = compiledFunction.allocateConstant(value);
+    int constId = functionBuilder.allocateConstant(value);
     builder.loadConst(constId);
   }
 
   void visitConstConstructorInvoke(
       NewExpression node,
       ConstructedConstantExpression constant,
       _) {
     doConstConstructorInvoke(constant);
     applyVisitState();
   }
@@ skipping 64 matching lines @@
           constructor,
           type,
           implementation.effectiveTarget,
           null,
           arguments,
           callStructure,
           null);
       return;
     }
     // TODO(ahe): Remove ".declaration" when issue 23135 is fixed.
-    CompiledFunction compiledFunction =
-        requireCompiledFunction(constructor.declaration);
+    FletchFunctionBuilder functionBuilder =
+        requireFletchFunctionBuilder(constructor.declaration);
     doStaticFunctionInvoke(
-        node, compiledFunction, arguments, callStructure, factoryInvoke: true);
+        node, functionBuilder, arguments, callStructure, factoryInvoke: true);
     applyVisitState();
   }
 
   void visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
@@ skipping 94 matching lines @@
     applyVisitState();
   }
 
   void handleStaticGetterGet(Send node, FunctionElement getter, _) {
     if (getter == context.backend.fletchExternalNativeError) {
       builder.loadSlot(0);
       return;
     }
     registerStaticInvocation(getter);
     int methodId = context.backend.functionMethodId(getter);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     invokeStatic(node, constId, 0);
     applyVisitState();
   }
 
   void handleStaticSetterSet(
       Send node,
       FunctionElement setter,
       Node rhs,
       _) {
     visitForValue(rhs);
     registerStaticInvocation(setter);
     int methodId = context.backend.functionMethodId(setter);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     invokeStatic(node, constId, 1);
     applyVisitState();
   }
 
   /**
    * Load the captured variables of [function], expressed in [info].
    *
    * If [function] captures itself, its field index is returned.
    */
   int pushCapturedVariables(FunctionElement function) {
@@ skipping 20 matching lines @@
     return thisClosureIndex;
   }
 
   void visitFunctionExpression(FunctionExpression node) {
     FunctionElement function = elements[node];
 
     // If the closure captures itself, thisClosureIndex is the field-index in
     // the closure.
     int thisClosureIndex = pushCapturedVariables(function);
 
-    CompiledClass compiledClass = context.backend.createClosureClass(
+    FletchClassBuilder classBuilder = context.backend.createClosureClass(
         function,
         closureEnvironment);
-    int classConstant = compiledFunction.allocateConstantFromClass(
-        compiledClass.id);
+    int classConstant = functionBuilder.allocateConstantFromClass(
+        classBuilder.id);
     bool immutable = !closureEnvironment.closures[function].free.any(
         closureEnvironment.shouldBeBoxed);
-    builder.allocate(classConstant, compiledClass.fields, immutable: immutable);
+    builder.allocate(classConstant, classBuilder.fields, immutable: immutable);
 
     if (thisClosureIndex >= 0) {
       builder.dup();
       builder.storeField(thisClosureIndex);
     }
 
     registerStaticInvocation(function);
     applyVisitState();
   }
 
@@ skipping 488 matching lines @@
     }
 
     // Pop exception slot.
     builder.pop();
   }
 
   void doUnresolved(String name) {
     var constString = context.backend.constantSystem.createString(
         new DartString.literal(name));
     context.markConstantUsed(constString);
-    builder.loadConst(compiledFunction.allocateConstant(constString));
+    builder.loadConst(functionBuilder.allocateConstant(constString));
     FunctionElement function = context.backend.fletchUnresolved;
     registerStaticInvocation(function);
     int methodId = context.backend.functionMethodId(function);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     builder.invokeStatic(constId, 1);
   }
 
   bool checkCompileError(Element element) {
     if (context.compiler.elementsWithCompileTimeErrors.contains(element)) {
       doCompileError();
       return true;
     }
     return false;
   }
 
   void doCompileError() {
     FunctionElement function = context.backend.fletchCompileError;
     registerStaticInvocation(function);
     int methodId = context.backend.functionMethodId(function);
-    int constId = compiledFunction.allocateConstantFromFunction(methodId);
+    int constId = functionBuilder.allocateConstantFromFunction(methodId);
     builder.invokeStatic(constId, 0);
   }
 
   void visitUnresolvedInvoke(
       Send node,
       Element element,
       Node arguments,
       Selector selector,
       _) {
     if (!checkCompileError(element)) {
@@ skipping 32 matching lines @@
   }
 
   void internalError(Spannable spannable, String reason) {
     context.compiler.internalError(spannable, reason);
   }
 
   void generateUnimplementedError(Spannable spannable, String reason) {
     context.backend.generateUnimplementedError(
         spannable,
         reason,
-        compiledFunction);
+        functionBuilder);
   }
 
   String toString() => "FunctionCompiler(${element.name})";
 
   void handleFinalStaticFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       _) {
     generateUnimplementedError(
@@ skipping 76 matching lines @@
   }
 
   void applyInitializers(FunctionExpression initializers, _) {
     internalError(node, "[applyInitializers] isn't implemented.");
   }
 
   void applyParameters(NodeList parameters, _) {
     internalError(node, "[applyParameters] isn't implemented.");
   }
 }