Move .getLocalFunction from KernelToElementMap to KernelToLocalsMap

pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, 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.world;
 
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
@@ skipping 359 matching lines @@
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
   void addFunctionCalledInLoop(MemberEntity element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
   void registerCannotThrow(FunctionEntity element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated. If [fromInstanceMember] is true, this
   /// closure class represents a closure that is inside an instance member, thus
   /// has access to `this`.
-  void registerClosureClass(covariant ClassEntity cls, bool fromInstanceMember);
+  void registerClosureClass(ClassEntity cls);
 }
 
 abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
   void registerClass(covariant ClassEntity cls);
 
   void registerUsedElement(MemberEntity element);
@@ skipping 909 matching lines @@
     MemberElement element = findMatchIn(cls, selector);
     if (element == null) return false;
 
     if (element.isAbstract) {
       ClassElement enclosingClass = element.enclosingClass;
       return hasConcreteMatch(enclosingClass.superclass, selector);
     }
     return selector.appliesUntyped(element);
   }
 
-  void registerClosureClass(ClassElement cls, bool _) {
+  void registerClosureClass(covariant ClassElement cls) {
     ClassHierarchyNode parentNode = getClassHierarchyNode(cls.superclass);
     ClassHierarchyNode node = _classHierarchyNodes[cls] =
         new ClassHierarchyNode(parentNode, cls, cls.hierarchyDepth);
     for (ResolutionInterfaceType type in cls.allSupertypes) {
       ClassSet subtypeSet = getClassSet(type.element);
       subtypeSet.addSubtype(node);
     }
     _classSets[cls] = new ClassSet(node);
     _updateSuperClassHierarchyNodeForClass(node);
     node.isDirectlyInstantiated = true;
@@ skipping 32 matching lines @@
   void computeRtiNeed(ResolutionWorldBuilder resolutionWorldBuilder,
       RuntimeTypesNeedBuilder rtiNeedBuilder,
       {bool enableTypeAssertions}) {
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         resolutionWorldBuilder, this,
         enableTypeAssertions: enableTypeAssertions);
   }
 
   RuntimeTypesNeed get rtiNeed => _rtiNeed;
 }