Remove Registry arguments from Enqueuer.

pkg/compiler/lib/src/resolution/registry.dart

 // Copyright (c) 2014, the Dart 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 file.
 
 library dart2js.resolution.registry;
 
 import '../common/backend_api.dart' show
     Backend;
 import '../common/registry.dart' show
     Registry;
@@ skipping 67 matching lines @@
     world.registerDynamicSetter(selector);
   }
 
   @override
   void registerGetOfStaticFunction(FunctionElement element) {
     world.registerGetOfStaticFunction(element);
   }
 
   @override
   void registerInstantiation(InterfaceType type) {
-    // TODO(johnniwinther): Remove the need for passing `this`.
-    world.registerInstantiatedType(type, this);
+    world.registerInstantiatedType(type);
   }
 
   @override
   void registerStaticInvocation(Element element) {
     registerDependency(element);
     world.registerStaticUse(element);
   }
 
   String toString() => 'EagerRegistry for ${mapping.analyzedElement}';
 }
@@ skipping 341 matching lines @@
     mapping.addRequiredType(type);
   }
 
   void registerAsCheck(DartType type) {
     registerIsCheck(type);
     backend.resolutionCallbacks.onAsCheck(type, this);
     mapping.addRequiredType(type);
   }
 
   void registerClosure(LocalFunctionElement element) {
-    world.registerClosure(element, this);
+    if (element.computeType(compiler).containsTypeVariables) {
+      backend.registerClosureWithFreeTypeVariables(element, world, this);
+    }
+    world.registerClosure(element);
   }
 
   void registerSuperUse(Node node) {
     mapping.addSuperUse(node);
   }
 
   void registerDynamicInvocation(UniverseSelector selector) {
     worldImpact.registerDynamicInvocation(selector);
   }
 
   void registerSuperNoSuchMethod() {
     backend.resolutionCallbacks.onSuperNoSuchMethod(this);
   }
 
   void registerTypeVariableExpression(TypeVariableElement element) {
     backend.resolutionCallbacks.onTypeVariableExpression(this, element);
   }
 
   void registerTypeLiteral(Send node, DartType type) {
     mapping.setType(node, type);
     backend.resolutionCallbacks.onTypeLiteral(type, this);
-    world.registerInstantiatedType(compiler.coreTypes.typeType, this);
+    backend.registerInstantiatedType(compiler.coreTypes.typeType, world, this);
   }
 
   void registerMapLiteral(Node node, DartType type, bool isConstant) {
     setType(node, type);
     backend.resolutionCallbacks.onMapLiteral(this, type, isConstant);
   }
 
   // TODO(johnniwinther): Remove the [ResolverVisitor] dependency. Its only
   // needed to lookup types in the current scope.
   void registerJsCall(Node node, ResolverVisitor visitor) {
@@ skipping 28 matching lines @@
 
   void registerConstSymbol(String name) {
     backend.registerConstSymbol(name, this);
   }
 
   void registerSymbolConstructor() {
     backend.resolutionCallbacks.onSymbolConstructor(this);
   }
 
   void registerInstantiatedType(InterfaceType type) {
-    world.registerInstantiatedType(type, this);
+    backend.registerInstantiatedType(type, world, this);
     mapping.addRequiredType(type);
   }
 
   void registerAbstractClassInstantiation() {
     backend.resolutionCallbacks.onAbstractClassInstantiation(this);
   }
 
   void registerNewSymbol() {
     backend.registerNewSymbol(this);
   }
@@ skipping 44 matching lines @@
 
   void registerStaticInvocation(Element element) {
     // TODO(johnniwinther): Increase precision of [registerStaticUse] and
     // [registerDependency].
     if (element == null) return;
     registerStaticUse(element);
     registerDependency(element);
   }
 
   void registerInstantiation(InterfaceType type) {
-    world.registerInstantiatedType(type, this);
+    backend.registerInstantiatedType(type, world, this);
   }
 
   void registerAssert(bool hasMessage) {
     backend.resolutionCallbacks.onAssert(hasMessage, this);
   }
 
   void registerSendStructure(Send node, SendStructure sendStructure) {
     mapping.setSendStructure(node, sendStructure);
   }
 
@@ skipping 12 matching lines @@
   }
 
   void registerIncDecOperation() {
     backend.resolutionCallbacks.onIncDecOperation(this);
   }
 
   void registerTryStatement() {
     mapping.containsTryStatement = true;
   }
 }