Move .getLocalFunction from KernelToElementMap to KernelToLocalsMap

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 380 matching lines @@
   FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
 
   FunctionEntity _getMethod(ir.Procedure node);
 
   @override
   FieldEntity getField(ir.Field node) => _getField(node);
 
   FieldEntity _getField(ir.Field node);
 
   @override
-  Local getLocalFunction(ir.TreeNode node) => _getLocalFunction(node);
-
-  Local _getLocalFunction(ir.TreeNode node);
-
-  @override
   DartType getDartType(ir.DartType type) => _typeConverter.convert(type);
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
     List<DartType> list = /*<DartType>*/ [];
     types.forEach((ir.DartType type) {
       list.add(getDartType(type));
     });
     return list;
@@ skipping 472 matching lines @@
   ParameterStructure _getParameterStructure(ir.FunctionNode node) {
     // TODO(johnniwinther): Cache the computed function type.
     int requiredParameters = node.requiredParameterCount;
     int positionalParameters = node.positionalParameters.length;
     List<String> namedParameters =
         node.namedParameters.map((p) => p.name).toList()..sort();
     return new ParameterStructure(
         requiredParameters, positionalParameters, namedParameters);
   }
 
-  Local _getLocalFunction(ir.TreeNode node) {
-    assert(
-        node is ir.FunctionDeclaration || node is ir.FunctionExpression,
-        failedAt(
-            CURRENT_ELEMENT_SPANNABLE, 'Invalid local function node: $node'));
-    return _localFunctionMap.putIfAbsent(node, () {
-      MemberEntity memberContext;
-      Entity executableContext;
-      ir.TreeNode parent = node.parent;
-      while (parent != null) {
-        if (parent is ir.Member) {
-          executableContext = memberContext = getMember(parent);
-          break;
-        }
-        if (parent is ir.FunctionDeclaration ||
-            parent is ir.FunctionExpression) {
-          Local localFunction = _getLocalFunction(parent);
-          executableContext = localFunction;
-          memberContext = localFunction.memberContext;
-          break;
-        }
-        parent = parent.parent;
-      }
-      String name;
-      FunctionType functionType;
-      if (node is ir.FunctionDeclaration) {
-        name = node.variable.name;
-        functionType = getFunctionType(node.function);
-      } else if (node is ir.FunctionExpression) {
-        functionType = getFunctionType(node.function);
-      }
-      return createLocalFunction(
-          name, memberContext, executableContext, functionType);
-    });
-  }
-
   IndexedLibrary createLibrary(int libraryIndex, String name, Uri canonicalUri);
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
       {bool isAbstract});
 
   TypeVariableEntity createTypeVariable(
       int typeVariableIndex, Entity typeDeclaration, String name, int index);
 
   IndexedConstructor createGenerativeConstructor(
       int memberIndex,
@@ skipping 27 matching lines @@
       bool isExternal,
       bool isAbstract});
 
   IndexedFunction createSetter(int memberIndex, LibraryEntity library,
       ClassEntity enclosingClass, Name name,
       {bool isStatic, bool isExternal, bool isAbstract});
 
   IndexedField createField(int memberIndex, LibraryEntity library,
       ClassEntity enclosingClass, Name name,
       {bool isStatic, bool isAssignable, bool isConst});
-
-  Local createLocalFunction(String name, MemberEntity memberContext,
-      Entity executableContext, FunctionType functionType);
 }
 
 /// Completes the [ElementCreatorMixin] by creating K-model elements.
 abstract class KElementCreatorMixin implements ElementCreatorMixin {
   IndexedLibrary createLibrary(
       int libraryIndex, String name, Uri canonicalUri) {
     return new KLibrary(libraryIndex, name, canonicalUri);
   }
 
   IndexedClass createClass(LibraryEntity library, int classIndex, String name,
@@ skipping 61 matching lines @@
     return new KSetter(memberIndex, library, enclosingClass, name,
         isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
   }
 
   IndexedField createField(int memberIndex, LibraryEntity library,
       ClassEntity enclosingClass, Name name,
       {bool isStatic, bool isAssignable, bool isConst}) {
     return new KField(memberIndex, library, enclosingClass, name,
         isStatic: isStatic, isAssignable: isAssignable, isConst: isConst);
   }
-
-  Local createLocalFunction(String name, MemberEntity memberContext,
-      Entity executableContext, FunctionType functionType) {
-    return new KLocalFunction(
-        name, memberContext, executableContext, functionType);
-  }
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 class KernelToElementMapForImpactImpl extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
         ElementCreatorMixin,
         KElementCreatorMixin {
   native.BehaviorBuilder _nativeBehaviorBuilder;
@@ skipping 28 matching lines @@
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
     return _memberData[method.memberIndex].node;
   }
 
   Iterable<ConstantValue> _getClassMetadata(KClass cls) {
     return _classData[cls.classIndex].getMetadata(this);
   }
+
+  @override
+  Local getLocalFunction(ir.TreeNode node) {
+    assert(
+        node is ir.FunctionDeclaration || node is ir.FunctionExpression,
+        failedAt(
+            CURRENT_ELEMENT_SPANNABLE, 'Invalid local function node: $node'));
+    return _localFunctionMap.putIfAbsent(node, () {
+      MemberEntity memberContext;
+      Entity executableContext;
+      ir.TreeNode parent = node.parent;
+      while (parent != null) {
+        if (parent is ir.Member) {
+          executableContext = memberContext = getMember(parent);
+          break;
+        }
+        if (parent is ir.FunctionDeclaration ||
+            parent is ir.FunctionExpression) {
+          Local localFunction = getLocalFunction(parent);
+          executableContext = localFunction;
+          memberContext = localFunction.memberContext;
+          break;
+        }
+        parent = parent.parent;
+      }
+      String name;
+      FunctionType functionType;
+      if (node is ir.FunctionDeclaration) {
+        name = node.variable.name;
+        functionType = getFunctionType(node.function);
+      } else if (node is ir.FunctionExpression) {
+        functionType = getFunctionType(node.function);
+      }
+      return new KLocalFunction(
+          name, memberContext, executableContext, functionType);
+    });
+  }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelToElementMapBase elementMap;
 
   KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
@@ skipping 550 matching lines @@
             allTypedefs,
             mixinUses,
             typesImplementedBySubclasses,
             classHierarchyNodes,
             classSets) {
     computeRtiNeed(resolutionWorldBuilder, rtiNeedBuilder,
         enableTypeAssertions: options.enableTypeAssertions);
   }
 
   @override
-  void registerClosureClass(ClassEntity cls, bool fromInstanceMember) {
-    // Tell the hierarchy that this is the super class. then we can use
-    // .getSupertypes(class)
-    IndexedClass superclass = fromInstanceMember
-        ? commonElements.boundClosureClass
-        : commonElements.closureClass;
-    ClassHierarchyNode parentNode = getClassHierarchyNode(superclass);
-    ClassHierarchyNode node = new ClassHierarchyNode(
-        parentNode, cls, getHierarchyDepth(superclass) + 1);
-    addClassHierarchyNode(cls, node);
-    for (InterfaceType type in getOrderedTypeSet(superclass).types) {
-      // TODO(efortuna): assert that the FunctionClass is in this ordered set.
-      // If not, we need to explicitly add node as a subtype of FunctionClass.
-      ClassSet subtypeSet = getClassSet(type.element);
-      subtypeSet.addSubtype(node);
-    }
-    addClassSet(cls, new ClassSet(node));
-
-    // Ensure that the supertype's hierarchy is completely set up.
-    var supertype = new InterfaceType(superclass, const []);
-    ClassData superdata = elementMap._classData[superclass.classIndex];
-    elementMap._ensureSupertypes(superclass, superdata);
-    elementMap._ensureThisAndRawType(superclass, superdata);
-
-    elementMap.addClosureClass(cls, supertype);
-    node.isDirectlyInstantiated = true;
+  void registerClosureClass(ClassEntity cls) {
+    throw new UnsupportedError('KernelClosedWorld.registerClosureClass');
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
 
   WorldDeconstructionForTesting(this.elementMap);
 
   IndexedClass getSuperclassForClass(IndexedClass cls) {
@@ skipping 306 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }