Register created closure class with the world.

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 12dc109b3899a1f3e0b39faea30edc6b0cee47a2..92fb8855ad2f085f8687417f34c9ee42a09fa1d9 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -28,6 +28,7 @@ import '../js_backend/interceptor_data.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../js_backend/runtime_types.dart';
+import '../js_model/closure.dart';
 import '../js_model/elements.dart';
 import '../native/enqueue.dart';
 import '../native/native.dart' as native;
@@ -656,6 +657,27 @@ abstract class ElementCreatorMixin {
     });
   }
 
+  void addClosureClass(KernelClosureClass cls, InterfaceType supertype) {
+    cls.classIndex = _classEnvs.length;
+    _classEnvs.add(new ClassEnv.closureClass());
+    _classList.add(cls);
+
+    // Create a classData and set up the interfaces and subclass
+    // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
+    var closureData = new ClassData(null);
+    closureData.isMixinApplication = false;

[Siggi Cherem (dart-lang), 2017/07/12 21:25:03]

nit: let's use cascades :)

[Emily Fortuna, 2017/07/12 22:02:18]

That was my plan before, but I must have had a syntax error because it wasn't
liking it. got it now, though.

+    closureData.thisType =
+        closureData.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+    closureData.supertype = supertype;
+    closureData.interfaces = const <InterfaceType>[];
+    var setBuilder =
+        new _KernelOrderedTypeSetBuilder((this as KernelToElementMapBase), cls);
+    _classData.add(closureData);
+    closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
+        closureData.supertype, const Link<InterfaceType>());
+    // TODO(efortuna): Does getMetadata get called in ClassData for this object?
+  }
+
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
@@ -664,7 +686,7 @@ abstract class ElementCreatorMixin {
       }
       _classEnvs.add(classEnv);
       _classData.add(new ClassData(node));
-      ClassEntity cls = createClass(library, _classMap.length, node.name,
+      ClassEntity cls = createClass(library, _classList.length, node.name,
           isAbstract: node.isAbstract);
       _classList.add(cls);
       return cls;
@@ -1536,7 +1558,7 @@ abstract class KernelClosedWorldMixin implements ClosedWorldBase {
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorldMixin.getSuperClass');
+    return elementMap._getSuperType(cls)?.element;
   }
 
   @override
@@ -1606,8 +1628,32 @@ class KernelClosedWorld extends ClosedWorldBase
   }
 
   @override
-  void registerClosureClass(ClassElement cls) {
-    throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
+  void registerClosureClass(ClassEntity cls, bool isInstanceMember) {
+    // Tell the hierarchy that this is the super class. then we can use
+    // .getSupertypes(class)
+    IndexedClass superclass = isInstanceMember
+        ? 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;
   }
 }