Rename CompiledFunction to FletchFunctionBuilder and CompiledClass to FletchClassBuilder.

pkg/fletchc/lib/compiler.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.compiler;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 18 matching lines @@
     SourceFileProvider;
 
 import 'package:compiler/src/elements/elements.dart' show
     ConstructorElement,
     ClassElement,
     FunctionElement;
 
 import 'package:compiler/src/filenames.dart' show
     appendSlash;
 
-import 'src/compiled_function.dart' show
-    CompiledFunction;
+import 'src/fletch_function_builder.dart' show
+    FletchFunctionBuilder;
 
 import 'src/debug_info.dart';
 
 import 'src/fletch_native_descriptor.dart' show
     FletchNativeDescriptor;
 
 import 'src/fletch_backend.dart' show
     FletchBackend;
 
-import 'src/compiled_class.dart' show
-    CompiledClass;
+import 'src/fletch_class_builder.dart' show
+    FletchClassBuilder;
 
 import 'package:compiler/src/apiimpl.dart' as apiimpl;
 
 import 'src/fletch_compiler.dart' as implementation;
 
 import 'bytecodes.dart' show
     Bytecode;
 
 import 'src/fletch_selector.dart';
 
@@ skipping 173 matching lines @@
     Map<String, FletchNativeDescriptor> natives =
         <String, FletchNativeDescriptor>{};
     Map<String, String> names = <String, String>{};
     FletchNativeDescriptor.decode(data, natives, names);
     _compiler.context.nativeDescriptors = natives;
     _compiler.context.setNames(names);
   }
 
   Uri get fletchVm => _compiler.fletchVm;
 
-  CompiledFunction lookupCompiledFunction(int methodId) {
-    CompiledFunction function = _compiler.context.backend.functions[methodId];
+  FletchFunctionBuilder lookupFletchFunctionBuilder(int methodId) {
+    FletchFunctionBuilder function =
+        _compiler.context.backend.functions[methodId];
     assert(function.methodId == methodId);
     return function;
   }
 
   String lookupFunctionName(int methodId) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     if (function == null) return '';
     if (function.isConstructor) {
       ConstructorElement constructor = function.element;
       ClassElement enclosing = constructor.enclosingClass;
       String name = (constructor.name == null || constructor.name.length == 0)
           ? ''
           : '.${constructor.name}';
       String postfix = function.isInitializerList ? ' initializer' : '';
       return '${enclosing.name}$name$postfix';
     }
     String functionName = function.name;
     if (functionName == null) return '';
-    CompiledClass memberOf = function.memberOf;
+    FletchClassBuilder memberOf = function.memberOf;
     if (memberOf == null) return functionName;
     if (memberOf.element == null) return functionName;
     if (functionName.isEmpty) return memberOf.element.name;
     return '${memberOf.element.name}.$functionName';
   }
 
-  CompiledClass lookupCompiledClass(int classId) {
-    CompiledClass klass = _compiler.context.backend.classes[classId];
+  FletchClassBuilder lookupFletchClassBuilder(int classId) {
+    FletchClassBuilder klass = _compiler.context.backend.classes[classId];
     assert(klass.id == classId);
     return klass;
   }
 
   String lookupClassName(int classId) {
-    CompiledClass klass = lookupCompiledClass(classId);
+    FletchClassBuilder klass = lookupFletchClassBuilder(classId);
     if (klass.element != null) return klass.element.name;
     // TODO(ager): Provide better information for closures.
     if (_compiler.context.backend.closureClasses.values.contains(klass)) {
       return 'closure';
     }
-    CompiledFunction function =
-        _compiler.context.backend.compiledFunctionFromTearoffClass(klass);
+    FletchFunctionBuilder function =
+        _compiler.context.backend.functionBuilderFromTearoffClass(klass);
     if (function != null) return 'tearoff of ${function.name}';
     return 'unknown';
   }
 
   String lookupFunctionNameBySelector(int selector) {
     int id = FletchSelector.decodeId(selector);
     return _compiler.context.symbols[id];
   }
 
   List<Bytecode> lookupFunctionBytecodes(int methodId) {
-    return lookupCompiledFunction(methodId).builder.bytecodes;
+    return lookupFletchFunctionBuilder(methodId).builder.bytecodes;
   }
 
   Iterable<int> lookupFunctionIdsByName(String name) {
     return _compiler.context.backend.functions
         .where((f) => f.name == name)
         .map((f) => f.methodId);
   }
 
   int mainMethodId() {
     FunctionElement mainFunctionElement = _compiler.mainFunction;
-    CompiledFunction mainMethod =
-        _compiler.context.backend.compiledFunctions[mainFunctionElement];
+    FletchFunctionBuilder mainMethod =
+        _compiler.context.backend.functionBuilders[mainFunctionElement];
     return mainMethod.methodId;
   }
 
   String astString(int methodId, int bytecodeIndex) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     _compiler.context.backend.ensureDebugInfo(function);
     return function.debugInfo.astStringFor(bytecodeIndex);
   }
 
   String fileAndLineString(int methodId, int bytecodeIndex) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     _compiler.context.backend.ensureDebugInfo(function);
     return function.debugInfo.fileAndLineStringFor(bytecodeIndex);
   }
 
   String sourceListString(int methodId,
                           int bytecodeIndex,
                           {int contextLines : 5}) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     _compiler.context.backend.ensureDebugInfo(function);
     return function.debugInfo.sourceListStringFor(bytecodeIndex, contextLines);
   }
 
   SourceLocation sourceLocation(int methodId, int bytecodeIndex) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     _compiler.context.backend.ensureDebugInfo(function);
     return function.debugInfo.sourceLocationFor(bytecodeIndex);
   }
 
   ScopeInfo scopeInfo(int methodId, int bytecodeIndex) {
-    CompiledFunction function = lookupCompiledFunction(methodId);
+    FletchFunctionBuilder function = lookupFletchFunctionBuilder(methodId);
     _compiler.context.backend.ensureDebugInfo(function);
     return function.debugInfo.scopeInfoFor(bytecodeIndex);
   }
 
   DebugInfo debugInfoForPosition(String file, int position) {
     return _compiler.debugInfoForPosition(file, position);
   }
 
   int positionInFileFromPattern(String file, int line, String pattern) {
     return _compiler.positionInFileFromPattern(file, line, pattern);
@@ skipping 109 matching lines @@
 
 Uri _guessPatchRoot(Uri libraryRoot) {
   Uri guess = libraryRoot.resolve('../../fletch/');
   if (_looksLikePatchRoot(guess)) return guess;
   return null;
 }
 
 bool _looksLikePatchRoot(Uri uri) {
   return _containsFile(uri, 'lib/core/core_patch.dart');
 }