Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/fletch_backend.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.fletch_backend;
 
 import 'dart:async' show
     Future;
 
 import 'dart:collection' show
     Queue;
 
-import 'package:compiler/src/dart2jslib.dart' show
+import 'package:compiler/src/common/backend_api.dart' show
     Backend,
-    BackendConstantEnvironment,
-    Compiler,
-    CompilerTask,
-    ConstantCompilerTask,
+    ImpactTransformer;
+
+import 'package:compiler/src/common/tasks.dart' show
+    CompilerTask;
+
+import 'package:compiler/src/enqueue.dart' show
     Enqueuer,
-    MessageKind,
-    Registry,
-    ResolutionCallbacks,
-    ResolutionEnqueuer,
-    isPrivateName;
+    ResolutionEnqueuer;
+
+import 'package:compiler/src/diagnostics/messages.dart' show
+    MessageKind;
+
+import 'package:compiler/src/common/registry.dart' show
+    Registry;
 
 import 'package:compiler/src/dart_types.dart' show
     DartType,
     InterfaceType;
 
 import 'package:compiler/src/tree/tree.dart' show
     DartString,
     EmptyStatement,
     Expression;
 
 import 'package:compiler/src/elements/elements.dart' show
     AbstractFieldElement,
     AstElement,
     ClassElement,
     ConstructorElement,
     Element,
     ExecutableElement,
     FieldElement,
     FormalElement,
     FunctionElement,
     FunctionSignature,
     FunctionTypedElement,
     LibraryElement,
     MemberElement,
     Name,
-    ParameterElement;
+    ParameterElement,
+    PublicName;
 
-import 'package:compiler/src/universe/universe.dart' show
-    CallStructure,
-    Selector,
-    UniverseSelector;
+import 'package:compiler/src/universe/selector.dart' show
+    Selector;
 
-import 'package:compiler/src/util/util.dart' show
+import 'package:compiler/src/universe/use.dart' show
+    DynamicUse,
+    StaticUse,
+    TypeUse,
+    TypeUseKind;
+
+import 'package:compiler/src/universe/call_structure.dart' show
+    CallStructure;
+
+import 'package:compiler/src/common.dart' show
     Spannable;
 
 import 'package:compiler/src/elements/modelx.dart' show
     FunctionElementX;
 
 import 'package:compiler/src/dart_backend/dart_backend.dart' show
     DartConstantTask;
 
 import 'package:compiler/src/constants/constant_system.dart' show
     ConstantSystem;
 
 import 'package:compiler/src/compile_time_constants.dart' show
     BackendConstantEnvironment;
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     FunctionConstantValue,
     ListConstantValue,
     MapConstantValue,
     StringConstantValue;
 
 import 'package:compiler/src/constants/expressions.dart' show
     ConstantExpression;
 
-import 'package:compiler/src/resolution/resolution.dart' show
+import 'package:compiler/src/resolution/tree_elements.dart' show
     TreeElements;
 
 import 'package:compiler/src/library_loader.dart' show
     LibraryLoader;
 
 import 'package:persistent/persistent.dart' show
     PersistentMap;
 
 import 'fletch_function_builder.dart' show
-    FletchFunctionKind,
-    FletchFunctionBuilder,
-    DebugInfo;
+    FletchFunctionBuilder;
 
 import 'fletch_class_builder.dart' show
     FletchClassBuilder;
 
 import 'fletch_system_builder.dart' show
     FletchSystemBuilder;
 
 import '../incremental_backend.dart' show
     IncrementalFletchBackend;
 
 import 'fletch_enqueuer.dart' show
     FletchEnqueueTask,
     shouldReportEnqueuingOfElement;
 
 import 'fletch_registry.dart' show
     ClosureKind,
     FletchRegistry;
 
 import 'diagnostic.dart' show
    throwInternalError;
 
+import 'package:compiler/src/common/names.dart' show
+    Identifiers,
+    Names;
+
+import 'package:compiler/src/universe/world_impact.dart' show
+    TransformedWorldImpact,
+    WorldImpact,
+    WorldImpactBuilder;
+
 import 'class_debug_info.dart';
 import 'codegen_visitor.dart';
 import 'debug_info.dart';
 import 'debug_info_constructor_codegen.dart';
 import 'debug_info_function_codegen.dart';
 import 'debug_info_lazy_field_initializer_codegen.dart';
 import 'fletch_context.dart';
 import 'fletch_selector.dart';
 import 'function_codegen.dart';
 import 'lazy_field_initializer_codegen.dart';
 import 'constructor_codegen.dart';
 import 'closure_environment.dart';
 
 import '../bytecodes.dart';
 import '../commands.dart';
 import '../fletch_system.dart';
+import 'package:compiler/src/common/resolution.dart';
 
 const FletchSystem BASE_FLETCH_SYSTEM = const FletchSystem(
     const PersistentMap<int, FletchFunction>(),
     const PersistentMap<Element, FletchFunction>(),
     const PersistentMap<ConstructorElement, FletchFunction>(),
     const PersistentMap<int, int>(),
     const PersistentMap<int, FletchClass>(),
     const PersistentMap<ClassElement, FletchClass>(),
     const <FletchConstant>[],
     const PersistentMap<int, String>(),
     const PersistentMap<int, int>(),
     const PersistentMap<int, int>());
 
-class FletchBackend extends Backend with ResolutionCallbacks
+class FletchBackend extends Backend
     implements IncrementalFletchBackend {
   static const String growableListName = '_GrowableList';
   static const String constantListName = '_ConstantList';
   static const String constantByteListName = '_ConstantByteList';
   static const String constantMapName = '_ConstantMap';
   static const String fletchNoSuchMethodErrorName = 'FletchNoSuchMethodError';
   static const String noSuchMethodName = '_noSuchMethod';
   static const String noSuchMethodTrampolineName = '_noSuchMethodTrampoline';
 
   final FletchContext context;
@@ skipping 60 matching lines @@
   ClassElement bigintClass;
   ClassElement uint32DigitsClass;
 
   /// Holds a reference to the class Coroutine if it exists.
   ClassElement coroutineClass;
 
   FletchSystemBuilder systemBuilder;
 
   final Set<FunctionElement> alwaysEnqueue = new Set<FunctionElement>();
 
+  FletchImpactTransformer impactTransformer;
+
   FletchBackend(FletchCompilerImplementation compiler)
       : this.context = compiler.context,
         this.constantCompilerTask = new DartConstantTask(compiler),
         this.systemBuilder = new FletchSystemBuilder(BASE_FLETCH_SYSTEM),
-        super(compiler);
+        super(compiler) {
+    this.impactTransformer = new FletchImpactTransformer(this);
+  }
 
   void newSystemBuilder(FletchSystem predecessorSystem) {
     systemBuilder = new FletchSystemBuilder(predecessorSystem);
   }
 
   FletchClassBuilder registerClassElement(ClassElement element) {
     if (element == null) return null;
     assert(element.isDeclaration);
 
     FletchClassBuilder classBuilder =
         systemBuilder.lookupClassBuilderByElement(element);
     if (classBuilder != null) return classBuilder;
 
     directSubclasses[element] = new Set<ClassElement>();
     FletchClassBuilder superclass = registerClassElement(element.superclass);
     if (superclass != null) {
       Set<ClassElement> subclasses = directSubclasses[element.superclass];
       subclasses.add(element);
     }
     classBuilder = systemBuilder.newClassBuilder(
         element, superclass, builtinClasses.contains(element));
 
     // TODO(ajohnsen): Currently, the FletchRegistry does not enqueue fields.
     // This is a workaround, where we basically add getters for all fields.
     classBuilder.updateImplicitAccessors(this);
 
-    Element callMember = element.lookupLocalMember(
-        Compiler.CALL_OPERATOR_NAME);
+    Element callMember = element.lookupLocalMember(Identifiers.call);
     if (callMember != null && callMember.isFunction) {
       FunctionElement function = callMember;
       classBuilder.createIsFunctionEntry(
           this, function.functionSignature.parameterCount);
     }
     return classBuilder;
   }
 
   FletchClassBuilder createCallableStubClass(
       int fields, int arity, FletchClassBuilder superclass) {
     FletchClassBuilder classBuilder = systemBuilder.newClassBuilder(
         null, superclass, false, extraFields: fields);
     classBuilder.createIsFunctionEntry(this, arity);
     return classBuilder;
   }
 
-  ResolutionCallbacks get resolutionCallbacks => this;
-
   List<CompilerTask> get tasks => <CompilerTask>[];
 
   ConstantSystem get constantSystem {
     return constantCompilerTask.constantCompiler.constantSystem;
   }
 
   BackendConstantEnvironment get constants => constantCompilerTask;
 
   bool classNeedsRti(ClassElement cls) => false;
 
   bool methodNeedsRti(FunctionElement function) => false;
 
-  void enqueueHelpers(ResolutionEnqueuer world, incomingRegistry) {
-    FletchRegistry registry = incomingRegistry;
+  void enqueueHelpers(ResolutionEnqueuer world, Registry incomingRegistry) {
+    FletchRegistry registry = new FletchRegistry(compiler);
     compiler.patchAnnotationClass = patchAnnotationClass;
 
     bool hasMissingHelpers = false;
     loadHelperMethods((String name) {
       LibraryElement library = fletchSystemLibrary;
       Element helper = library.findLocal(name);
       // TODO(ahe): Make it cleaner.
       if (helper != null && helper.isAbstractField) {
         AbstractFieldElement abstractField = helper;
         helper = abstractField.getter;
       }
       if (helper == null) {
         hasMissingHelpers = true;
-        compiler.reportError(
+        compiler.reporter.reportErrorMessage(
             library, MessageKind.GENERIC,
             {'text': "Required implementation method '$name' not found."});
       }
       return helper;
     });
     if (hasMissingHelpers) {
       throwInternalError(
           "Some implementation methods are missing, see details above");
     }
-    world.registerStaticUse(fletchCompileError);
-    world.registerStaticUse(fletchSystemEntry);
-    world.registerStaticUse(fletchUnresolved);
+    world.registerStaticUse(
+        new StaticUse.staticInvoke(fletchCompileError, CallStructure.NO_ARGS));
+    world.registerStaticUse(
+        new StaticUse.staticInvoke(fletchSystemEntry, CallStructure.ONE_ARG));
+    world.registerStaticUse(
+        new StaticUse.staticInvoke(fletchUnresolved, CallStructure.ONE_ARG));
 
     loadHelperClasses((
         String name,
         LibraryElement library,
         {bool builtin: false}) {
       var classImpl = library.findLocal(name);
       if (classImpl == null) classImpl = library.implementation.find(name);
       if (classImpl == null) {
-        compiler.reportError(
+        compiler.reporter.reportErrorMessage(
             library, MessageKind.GENERIC,
             {'text': "Required implementation class '$name' not found."});
         hasMissingHelpers = true;
         return null;
       }
       if (hasMissingHelpers) return null;
       if (builtin) builtinClasses.add(classImpl);
       {
         // TODO(ahe): Register in ResolutionCallbacks. The lines in this block
         // should not happen at this point in time.
-        classImpl.ensureResolved(compiler);
-        world.registerInstantiatedType(classImpl.rawType, registry.asRegistry);
+        classImpl.ensureResolved(compiler.resolution);
+        world.registerInstantiatedType(classImpl.rawType);
         // TODO(ahe): This is a hack to let both the world and the codegen know
         // about the instantiated type.
         registry.registerInstantiatedType(classImpl.rawType);
       }
       return registerClassElement(classImpl);
     });
     if (hasMissingHelpers) {
       throwInternalError(
           "Some implementation classes are missing, see details above");
     }
 
     // Register list constructors to world.
     // TODO(ahe): Register growableListClass through ResolutionCallbacks.
-    growableListClass.constructors.forEach(world.registerStaticUse);
+    growableListClass.constructors.forEach((Element element) {
+      world.registerStaticUse(new StaticUse.constructorInvoke(element, null));
+    });
 
     // TODO(ajohnsen): Remove? String interpolation does not enqueue '+'.
     // Investigate what else it may enqueue, could be StringBuilder, and then
     // consider using that instead.
-    var selector = new UniverseSelector(new Selector.binaryOperator('+'), null);
-    world.registerDynamicInvocation(selector);
+    world.registerDynamicUse(
+        new DynamicUse(new Selector.binaryOperator('+'), null));
 
-    selector = new UniverseSelector(new Selector.call('add', null, 1), null);
-    world.registerDynamicInvocation(selector);
+    world.registerDynamicUse(new DynamicUse(
+        new Selector.call(new PublicName('add'), CallStructure.ONE_ARG), null));
 
-    alwaysEnqueue.add(compiler.objectClass.implementation.lookupLocalMember(
-        noSuchMethodTrampolineName));
-    alwaysEnqueue.add(compiler.objectClass.implementation.lookupLocalMember(
-        noSuchMethodName));
+    alwaysEnqueue.add(
+        compiler.coreClasses.objectClass.implementation.lookupLocalMember(
+            noSuchMethodTrampolineName));
+    alwaysEnqueue.add(
+        compiler.coreClasses.objectClass.implementation.lookupLocalMember(
+            noSuchMethodName));
 
     if (coroutineClass != null) {
       builtinClasses.add(coroutineClass);
       alwaysEnqueue.add(coroutineClass.lookupLocalMember("_coroutineStart"));
     }
 
     for (FunctionElement element in alwaysEnqueue) {
-      world.registerStaticUse(element);
+      world.registerStaticUse(new StaticUse.foreignUse(element));
     }
   }
 
   void loadHelperMethods(
       FunctionElement findHelper(String name)) {
 
     FunctionElement findExternal(String name) {
       FunctionElement helper = findHelper(name);
       if (helper != null) externals.add(helper);
       return helper;
@@ skipping 39 matching lines @@
     growableListClass =
         loadClass(growableListName, fletchSystemLibrary)?.element;
     fletchNoSuchMethodErrorClass =
         loadClass(fletchNoSuchMethodErrorName,
                   fletchSystemLibrary,
                   builtin: true)?.element;
 
     // This class is optional.
     coroutineClass = fletchSystemLibrary.implementation.find("Coroutine");
     if (coroutineClass != null) {
-      coroutineClass.ensureResolved(compiler);
+      coroutineClass.ensureResolved(compiler.resolution);
     }
   }
 
   void onElementResolved(Element element, TreeElements elements) {
     if (alwaysEnqueue.contains(element)) {
-      var registry = new FletchRegistry(compiler, elements);
-      registry.registerStaticInvocation(element);
+      var registry = new FletchRegistry(compiler);
+      if (element.isStatic || element.isTopLevel) {
+        registry.registerStaticUse(new StaticUse.foreignUse(element));
+      } else {
+        registry.registerDynamicUse(new Selector.fromElement(element));
+      }
     }
   }
 
-  void onMapLiteral(Registry registry, DartType type, bool isConstant) {
-    if (isConstant) return;
-    ClassElement classImpl = mapImplementation;
-    registry.registerInstantiation(classImpl.rawType);
-    registry.registerStaticInvocation(classImpl.lookupDefaultConstructor());
-  }
-
   ClassElement get intImplementation => smiClass;
 
   /// Class of annotations to mark patches in patch files.
   ///
   /// The patch parser (pkg/compiler/lib/src/patch_parser.dart). The patch
   /// parser looks for an annotation on the form "@patch", where "patch" is
   /// compile-time constant instance of [patchAnnotationClass].
   ClassElement get patchAnnotationClass {
     // TODO(ahe): Introduce a proper constant class to identify constants. For
-    // now, we simply put "const patch = "patch";" in the beginning of patch
-    // files.
+    // now, we simply put "const patch = "patch";" in fletch._system.
     return super.stringImplementation;
   }
 
   FletchClassBuilder createClosureClass(
       FunctionElement closure,
       ClosureEnvironment closureEnvironment) {
     return closureClasses.putIfAbsent(closure, () {
       ClosureInfo info = closureEnvironment.closures[closure];
       int fields = info.free.length;
       if (info.isThisFree) fields++;
@@ skipping 216 matching lines @@
         elements);
     CodegenVisitor codegen;
     FletchFunctionBuilder builder =
         new FletchFunctionBuilder.fromFletchFunction(function);
     if (function.isLazyFieldInitializer) {
       codegen = new DebugInfoLazyFieldInitializerCodegen(
           debugInfo,
           builder,
           context,
           elements,
-          null,
           closureEnvironment,
           element,
           compiler);
     } else if (function.isInitializerList) {
       ClassElement enclosingClass = element.enclosingClass;
       // TODO(ajohnsen): Don't depend on the class builder.
       FletchClassBuilder classBuilder =
           systemBuilder.lookupClassBuilderByElement(enclosingClass.declaration);
       codegen = new DebugInfoConstructorCodegen(
           debugInfo,
           builder,
           context,
           elements,
-          null,
           closureEnvironment,
           element,
           classBuilder,
           compiler);
     } else {
       codegen = new DebugInfoFunctionCodegen(
           debugInfo,
           builder,
           context,
           elements,
-          null,
           closureEnvironment,
           element,
           compiler);
     }
     if (isNative(element)) {
-      compiler.withCurrentElement(element, () {
+      compiler.reporter.withCurrentElement(element, () {
         codegenNativeFunction(element, codegen);
       });
     } else if (isExternal(element)) {
-      compiler.withCurrentElement(element, () {
+      compiler.reporter.withCurrentElement(element, () {
         codegenExternalFunction(element, codegen);
       });
     } else {
-      compiler.withCurrentElement(element, () { codegen.compile(); });
+      compiler.reporter.withCurrentElement(element, () { codegen.compile(); });
     }
     // The debug codegen should generate the same bytecodes as the original
     // codegen. If that is not the case debug information will be useless.
     assert(Bytecode.identicalBytecodes(expectedBytecodes,
                                        codegen.assembler.bytecodes));
     return debugInfo;
   }
 
   codegen(_) {
     new UnsupportedError(
         "Method [codegen] not supported, use [compileElement] instead");
   }
 
   /// Invoked by [FletchEnqueuer] once per element that needs to be compiled.
   ///
   /// This is used to generate the bytecodes for [declaration].
   void compileElement(
       AstElement declaration,
       TreeElements treeElements,
       FletchRegistry registry) {
     AstElement element = declaration.implementation;
-    compiler.withCurrentElement(element, () {
+    compiler.reporter.withCurrentElement(element, () {
       assert(declaration.isDeclaration);
       context.compiler.reportVerboseInfo(element, 'Compiling $element');
       if (element.isFunction ||
           element.isGetter ||
           element.isSetter ||
-          element.isGenerativeConstructor) {
+          element.isGenerativeConstructor ||
+          element.isFactoryConstructor) {
         // For a generative constructor, this means compile the constructor
         // body. See [compilePendingConstructorInitializers] for an overview of
         // how constructor initializers and constructor bodies are compiled.
         codegenFunction(element, treeElements, registry);
       } else if (element.isField) {
         context.compiler.reportVerboseInfo(
             element, "Asked to compile a field, but don't know how");
       } else {
-        compiler.internalError(
+        compiler.reporter.internalError(
             element, "Uninimplemented element kind: ${element.kind}");
       }
     });
   }
 
   /// Invoked by [FletchEnqueuer] once per [selector] that may invoke
   /// [declaration].
   ///
   /// This is used to generate stubs for [declaration].
   void compileElementUsage(
       AstElement declaration,
       Selector selector,
       TreeElements treeElements,
       FletchRegistry registry) {
     AstElement element = declaration.implementation;
-    compiler.withCurrentElement(element, () {
+    compiler.reporter.withCurrentElement(element, () {
       assert(declaration.isDeclaration);
       context.compiler.reportVerboseInfo(element, 'Compiling $element');
       if (!element.isInstanceMember && !isLocalFunction(element)) {
         // No stub needed. Optional arguments are handled at call-site.
       } else if (element.isFunction) {
         FletchFunctionBase function =
             systemBuilder.lookupFunctionBuilderByElement(element.declaration);
         CallStructure callStructure = selector.callStructure;
         FunctionSignature signature = function.signature;
         if (selector.isGetter) {
@@ skipping 26 matching lines @@
   /// [declaration] as an implicit closure (for example, a tear-off).
   ///
   /// This is used to generate parameter stubs for the closures.
   void compileClosurizationUsage(
       AstElement declaration,
       Selector selector,
       TreeElements treeElements,
       FletchRegistry registry,
       ClosureKind kind) {
     AstElement element = declaration.implementation;
-    compiler.withCurrentElement(element, () {
+    compiler.reporter.withCurrentElement(element, () {
       assert(declaration.isDeclaration);
       if (shouldReportEnqueuingOfElement(compiler, element)) {
         context.compiler.reportVerboseInfo(
             element, 'Need tear-off parameter stub $selector');
       }
       FletchFunctionBase function =
           systemBuilder.lookupFunctionByElement(element.declaration);
       if (function == null) {
-        compiler.internalError(
+        compiler.reporter.internalError(
             element, "Has no fletch function, but used as tear-off");
       }
       if (selector.isGetter) {
         // This is a special tear-off getter.
 
         // TODO(ahe): This code should probably use [kind] to detect the
         // various cases instead of [isLocalFunction] and looking at names.
 
-        assert(selector.memberName == Selector.CALL_NAME);
+        assert(selector.memberName == Names.CALL_NAME);
         if (isLocalFunction(element) ||
-            memberName(element) == Selector.CALL_NAME) {
+            memberName(element) == Names.CALL_NAME) {
           createTearoffGetterForFunction(
               function, isSpecialCallMethod: true);
           return;
         }
         int stub = systemBuilder.lookupTearOffById(function.functionId);
         if (stub == null) {
-          compiler.internalError(
+          compiler.reporter.internalError(
               element, "No tear-off stub to compile `call` tear-off");
         } else {
           function = systemBuilder.lookupFunction(stub);
           createTearoffGetterForFunction(function, isSpecialCallMethod: true);
           return;
         }
       }
       switch (kind) {
         case ClosureKind.tearOff:
         case ClosureKind.superTearOff:
-          if (memberName(element) == Selector.CALL_NAME) {
+          if (memberName(element) == Names.CALL_NAME) {
             // This is really a functionLikeTearOff.
             break;
           }
           // A tear-off has a corresponding stub in a closure class. Look up
           // that stub:
           int stub = systemBuilder.lookupTearOffById(function.functionId);
           if (stub == null) {
-            compiler.internalError(element, "Couldn't find tear-off stub");
+            compiler.reporter
+                .internalError(element, "Couldn't find tear-off stub");
           } else {
             function = systemBuilder.lookupFunction(stub);
           }
           break;
 
         case ClosureKind.localFunction:
           // A local function already is a member of its closure class, and
           // doesn't have a stub.
           break;
 
         case ClosureKind.functionLike:
         case ClosureKind.functionLikeTearOff:
-          compiler.internalError(element, "Unimplemented: $kind");
+          compiler.reporter.internalError(element, "Unimplemented: $kind");
           break;
       }
 
       if (!isExactParameterMatch(function.signature, selector.callStructure)) {
         createParameterStubFor(function, selector);
       }
     });
   }
 
   void codegenFunction(
       FunctionElement function,
       TreeElements elements,
       FletchRegistry registry) {
-    registry.registerStaticInvocation(fletchSystemEntry);
+    registry.registerStaticUse(new StaticUse.foreignUse(fletchSystemEntry));
 
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         function,
         elements);
 
     FletchFunctionBuilder functionBuilder;
 
     if (function.memberContext != function) {
       functionBuilder = internalCreateFletchFunctionBuilder(
           function,
-          Compiler.CALL_OPERATOR_NAME,
+          Identifiers.call,
           createClosureClass(function, closureEnvironment));
     } else {
       functionBuilder = createFletchFunctionBuilder(function);
     }
 
     FunctionCodegen codegen = new FunctionCodegen(
         functionBuilder,
         context,
         elements,
         registry,
@@ skipping 62 matching lines @@
 
     FletchNativeDescriptor descriptor = context.nativeDescriptors[name];
     if (descriptor == null) {
       throw "Unsupported native function: $name";
     }
 
     if (name == "Coroutine._coroutineNewStack") {
       // The static native method `Coroutine._coroutineNewStack` will invoke
       // the instance method `Coroutine._coroutineStart`.
       if (coroutineClass == null) {
-        compiler.internalError(
+        compiler.reporter.internalError(
             function, "required class [Coroutine] not found");
       }
       FunctionElement coroutineStart =
           coroutineClass.lookupLocalMember("_coroutineStart");
       Selector selector = new Selector.fromElement(coroutineStart);
-      new FletchRegistry(compiler, function.resolvedAst.elements)
-          ..registerDynamicInvocation(new UniverseSelector(selector, null));
+      new FletchRegistry(compiler)
+          ..registerDynamicUse(selector);
     } else if (name == "Process._spawn") {
       // The native method `Process._spawn` will do a closure invoke with 0, 1,
       // or 2 arguments.
-      new FletchRegistry(compiler, function.resolvedAst.elements)
-          ..registerDynamicInvocation(
-              new UniverseSelector(new Selector.callClosure(0), null))
-          ..registerDynamicInvocation(
-              new UniverseSelector(new Selector.callClosure(1), null))
-          ..registerDynamicInvocation(
-              new UniverseSelector(new Selector.callClosure(2), null));
+      new FletchRegistry(compiler)
+          ..registerDynamicUse(new Selector.callClosure(0))
+          ..registerDynamicUse(new Selector.callClosure(1))
+          ..registerDynamicUse(new Selector.callClosure(2));
     }
 
     int arity = codegen.assembler.functionArity;
     if (name == "Port.send" ||
         name == "Port._sendList" ||
         name == "Port._sendExit") {
       codegen.assembler.invokeNativeYield(arity, descriptor.index);
     } else {
       codegen.assembler.invokeNative(arity, descriptor.index);
     }
@@ skipping 15 matching lines @@
     if (function == fletchExternalYield) {
       codegenExternalYield(function, codegen);
     } else if (function == context.compiler.identicalFunction.implementation) {
       codegenIdentical(function, codegen);
     } else if (function == fletchExternalInvokeMain) {
       codegenExternalInvokeMain(function, codegen);
     } else if (function.name == noSuchMethodTrampolineName &&
                function.library == compiler.coreLibrary) {
       codegenExternalNoSuchMethodTrampoline(function, codegen);
     } else {
-      compiler.reportError(
+      compiler.reporter.reportErrorMessage(
           function.node,
           MessageKind.GENERIC,
           {'text': 'External function is not supported'});
       codegen
           ..doCompileError()
           ..assembler.ret()
           ..assembler.methodEnd();
     }
   }
 
@@ skipping 14 matching lines @@
     codegen.assembler
         ..loadParameter(0)
         ..processYield()
         ..ret()
         ..methodEnd();
   }
 
   void codegenExternalInvokeMain(
       FunctionElement function,
       FunctionCodegen codegen) {
-    compiler.internalError(
+    compiler.reporter.internalError(
         function, "[codegenExternalInvokeMain] not implemented.");
     // TODO(ahe): This code shouldn't normally be called, only if invokeMain is
     // torn off. Perhaps we should just say we don't support that.
   }
 
   void codegenExternalNoSuchMethodTrampoline(
       FunctionElement function,
       FunctionCodegen codegen) {
     // NOTE: The number of arguments to the [noSuchMethodName] function must be
     // kept in sync with:
     //     src/vm/interpreter.cc:HandleEnterNoSuchMethod
     int id = context.getSymbolId(
-        context.mangleName(noSuchMethodName, compiler.coreLibrary));
+        context.mangleName(new Name(noSuchMethodName, compiler.coreLibrary)));
     int fletchSelector = FletchSelector.encodeMethod(id, 3);
     BytecodeLabel skipGetter = new BytecodeLabel();
     codegen.assembler
         ..enterNoSuchMethod(skipGetter)
         // First invoke the getter.
         ..invokeSelector()
         // Then invoke 'call', with the receiver being the result of the
         // previous invokeSelector.
         ..invokeSelector()
         ..exitNoSuchMethod()
@@ skipping 35 matching lines @@
       return environment.compute();
     });
   }
 
   void markFunctionConstantAsUsed(FunctionConstantValue value) {
     // TODO(ajohnsen): Use registry in CodegenVisitor to register the used
     // constants.
     FunctionElement function = value.element;
     createTearoffClass(createFletchFunctionBuilder(function));
     // Be sure to actually enqueue the function for compilation.
-    FletchRegistry registry =
-        new FletchRegistry(compiler, function.resolvedAst.elements);
-    registry.registerStaticInvocation(function);
+    FletchRegistry registry = new FletchRegistry(compiler);
+    registry.registerStaticUse(new StaticUse.foreignUse(function));
   }
 
   FletchFunctionBase createParameterStubFor(
       FletchFunctionBase function,
       Selector selector) {
     CallStructure callStructure = selector.callStructure;
     assert(callStructure.signatureApplies(function.signature));
     FletchFunctionBase stub = systemBuilder.parameterStubFor(
         function,
         callStructure);
@@ skipping 107 matching lines @@
           ..allocate(constId, tearoffClass.fields)
           ..ret()
           ..methodEnd();
     }
     // If the name is private, we need the library.
     // Invariant: We only generate public stubs, e.g. 'call'.
     LibraryElement library;
     if (function.element != null) {
       library = function.element.library;
     }
+    // TODO(sigurdm): Avoid allocating new name here.
+    Name name = new Name(function.name, library);
     int fletchSelector = context.toFletchSelector(
-        new Selector.getter(function.name, library));
+        new Selector.getter(name));
     FletchClassBuilder classBuilder = systemBuilder.lookupClassBuilder(
         function.memberOf);
     classBuilder.addToMethodTable(fletchSelector, getter);
 
     // Inject getter into all mixin usages.
     getMixinApplicationsOfClass(classBuilder).forEach((ClassElement usage) {
       FletchClassBuilder classBuilder =
           systemBuilder.lookupClassBuilderByElement(usage);
       classBuilder.addToMethodTable(fletchSelector, getter);
     });
@@ skipping 32 matching lines @@
 
   bool enableCodegenWithErrorsIfSupported(Spannable spannable) {
     return true;
   }
 
   bool enableDeferredLoadingIfSupported(Spannable spannable, Registry registry) {
     return false;
   }
 
   bool registerDeferredLoading(Spannable node, Registry registry) {
-    compiler.reportWarning(
+    compiler.reporter.reportWarningMessage(
         node,
         MessageKind.GENERIC,
         {'text': "Deferred loading is not supported."});
     return false;
   }
 
   bool get supportsReflection => false;
 
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     if (Uri.parse('dart:fletch._system') == library.canonicalUri) {
@@ skipping 27 matching lines @@
 
   /// Return non-null to enable patching. Possible return values are 'new' and
   /// 'old'. Referring to old and new emitter. Since the new emitter is the
   /// future, we assume 'old' will go away. So it seems the best option for
   /// Fletch is 'new'.
   String get patchVersion => 'new';
 
   FunctionElement resolveExternalFunction(FunctionElement element) {
     if (element.isPatched) {
       FunctionElementX patch = element.patch;
-      compiler.withCurrentElement(patch, () {
-        patch.parseNode(compiler);
-        patch.computeType(compiler);
+      compiler.reporter.withCurrentElement(patch, () {
+        patch.parseNode(compiler.parsing);
+        patch.computeType(compiler.resolution);
       });
       element = patch;
       // TODO(ahe): Don't use ensureResolved (fix TODO in isNative instead).
-      element.metadata.forEach((m) => m.ensureResolved(compiler));
+      element.metadata.forEach((m) => m.ensureResolved(compiler.resolution));
     } else if (element.library == fletchSystemLibrary) {
       // Nothing needed for now.
     } else if (element.library == compiler.coreLibrary) {
       // Nothing needed for now.
     } else if (element.library == mathLibrary) {
       // Nothing needed for now.
     } else if (element.library == asyncLibrary) {
       // Nothing needed for now.
     } else if (element.library == fletchLibrary) {
       // Nothing needed for now.
     } else if (externals.contains(element)) {
       // Nothing needed for now.
     } else {
-      compiler.reportError(
+      compiler.reporter.reportErrorMessage(
           element, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
     }
     return element;
   }
 
   int compileLazyFieldInitializer(
       FieldElement field,
       FletchRegistry registry) {
     int index = context.getStaticFieldIndex(field, null);
 
@@ skipping 27 matching lines @@
     return index;
   }
 
   /// Compiles the initializer part of a constructor.
   ///
   /// See [compilePendingConstructorInitializers] for an overview of how
   /// constructor initializer and bodies are compiled.
   void compileConstructorInitializer(FletchFunctionBuilder functionBuilder) {
     ConstructorElement constructor = functionBuilder.element;
     assert(constructor.isImplementation);
-    compiler.withCurrentElement(constructor, () {
+    compiler.reporter.withCurrentElement(constructor, () {
       assert(functionBuilder ==
           systemBuilder.lookupConstructorInitializerByElement(constructor));
       context.compiler.reportVerboseInfo(
           constructor, 'Compiling constructor initializer $constructor');
 
       TreeElements elements = constructor.resolvedAst.elements;
 
       // TODO(ahe): We shouldn't create a registry, but we have to as long as
       // the enqueuer doesn't support elements with more than one compilation
       // artifact.
-      FletchRegistry registry =
-          new FletchRegistry(compiler, elements);
+      FletchRegistry registry = new FletchRegistry(compiler);
 
       FletchClassBuilder classBuilder =
           registerClassElement(constructor.enclosingClass.declaration);
 
       ClosureEnvironment closureEnvironment =
           createClosureEnvironment(constructor, elements);
 
       ConstructorCodegen codegen = new ConstructorCodegen(
           functionBuilder,
           context,
@@ skipping 25 matching lines @@
   int makeSetter(int fieldIndex) {
     return systemBuilder.getSetterByFieldIndex(fieldIndex);
   }
 
   void generateUnimplementedError(
       Spannable spannable,
       String reason,
       FletchFunctionBuilder function,
       {bool suppressHint: false}) {
     if (!suppressHint) {
-      compiler.reportHint(
+      compiler.reporter.reportHintMessage(
           spannable, MessageKind.GENERIC, {'text': reason});
     }
     var constString = constantSystem.createString(
         new DartString.literal(reason));
     context.markConstantUsed(constString);
     function
         ..assembler.loadConst(function.allocateConstant(constString))
         ..assembler.emitThrow();
   }
 
@@ skipping 76 matching lines @@
   /// us to compile a generative constructor (see [codegen]), and track
   /// constructor initializers in a separate queue.
   void compilePendingConstructorInitializers() {
     while (pendingConstructorInitializers.isNotEmpty) {
       compileConstructorInitializer(
           pendingConstructorInitializers.removeLast());
     }
   }
 
   bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassElement> recentClasses) {
-    if (!enqueuer.isResolutionQueue) {
+    if (enqueuer is! ResolutionEnqueuer) {
       compilePendingConstructorInitializers();
     }
-    return super.onQueueEmpty(enqueuer, recentClasses);
+    return true;
   }
 
   FletchEnqueueTask makeEnqueuer() => new FletchEnqueueTask(compiler);
 
   static bool isExactParameterMatch(
       FunctionSignature signature,
       CallStructure callStructure) {
     if (!callStructure.signatureApplies(signature)) {
       return false;
     }
@@ skipping 18 matching lines @@
     int index = 0;
     for (var parameter in signature.orderedOptionalParameters) {
       if (parameter.name != callStructure.namedArguments[index++]) return false;
     }
     return true;
   }
 
   static FletchBackend newInstance(FletchCompilerImplementation compiler) {
     return new FletchBackend(compiler);
   }
+
+  Uri resolvePatchUri(String libraryName, Uri libraryRoot) {
+    throw "Not implemented";
+  }
+
+}
+
+class FletchImpactTransformer extends ImpactTransformer {
+  final FletchBackend backend;
+
+  FletchImpactTransformer(this.backend);
+
+  @override
+  WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) {
+    FletchRegistry registry = new FletchRegistry(backend.compiler);
+    TransformedWorldImpact transformed =
+        new TransformedWorldImpact(worldImpact);
+
+    if (worldImpact.constSymbolNames.isNotEmpty) {
+      ClassElement symbolClass =
+          backend.compiler.coreClasses.symbolClass.declaration;
+      transformed.registerTypeUse(
+          new TypeUse.instantiation(symbolClass.rawType));
+      transformed.registerStaticUse(
+          new StaticUse.foreignUse(
+              symbolClass.lookupConstructor("")));
+    }
+
+    for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
+      if (mapLiteralUse.isConstant) continue;
+      transformed.registerTypeUse(
+          new TypeUse.instantiation(backend.mapImplementation.rawType));
+      transformed.registerStaticUse(
+          new StaticUse.constructorInvoke(
+              backend.mapImplementation.lookupConstructor(""),
+              CallStructure.NO_ARGS));
+    }
+    return transformed;
+  }
+
+  @override
+  transformCodegenImpact(impact) => throw "unimplemented";
 }
 
 bool isLocalFunction(Element element) {
   if (!element.isFunction) return false;
   if (element is ExecutableElement) {
     return element.memberContext != element;
   }
   return false;
 }
 
 Name memberName(AstElement element) {
   if (isLocalFunction(element)) return null;
   MemberElement member = element;
   return member.memberName;
 }