Move .getLocalFunction from KernelToElementMap to KernelToLocalsMap

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

Index: pkg/compiler/lib/src/kernel/element_map_impl.dart
diff --git a/pkg/compiler/lib/src/kernel/element_map_impl.dart b/pkg/compiler/lib/src/kernel/element_map_impl.dart
index 642806795aac7108b8ac6ded81471beac1f0d485..018651b242f13088ca6aae48c600d5bdb580e9b3 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -398,11 +398,6 @@ abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {
   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) {
@@ -895,42 +890,6 @@ abstract class ElementCreatorMixin {
         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,
@@ -978,9 +937,6 @@ abstract class ElementCreatorMixin {
   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.
@@ -1062,12 +1018,6 @@ abstract class KElementCreatorMixin implements ElementCreatorMixin {
     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
@@ -1116,6 +1066,45 @@ class KernelToElementMapForImpactImpl extends KernelToElementMapBase
   Iterable<ConstantValue> _getClassMetadata(KClass cls) {
     return _classData[cls.classIndex].getMetadata(this);
   }
+
+  @override
+  Local getLocalFunction(ir.TreeNode node) => _getLocalFunction(node);
+
+  Local _getLocalFunction(ir.TreeNode node) {

[Emily Fortuna, 2017/07/21 22:21:43]

I know you've done this elsewhere, but why the public and private versions of
this method when they are identical?

[Johnni Winther, 2017/07/28 12:08:19]

Not needed here (now remove). I other places it was needed to add additional
arguments to the implementation method or restricting the type in ways not
allowed by strong mode.

+    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 {
@@ -1686,32 +1675,8 @@ class KernelClosedWorld extends ClosedWorldBase
   }
 
   @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');
   }
 }