Register created closure class with the world.

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 10 matching lines @@
 import '../elements/names.dart';
 import '../elements/types.dart';
 import '../environment.dart';
 import '../frontend_strategy.dart';
 import '../js_backend/backend_usage.dart';
 import '../js_backend/constant_system_javascript.dart';
 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;
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../options.dart';
 import '../universe/class_set.dart';
 import '../universe/selector.dart';
 import '../universe/world_builder.dart';
 import '../world.dart';
@@ skipping 608 matching lines @@
         String path = canonicalUri.path;
         name = path.substring(path.lastIndexOf('/') + 1);
       }
       LibraryEntity library =
           createLibrary(_libraryMap.length, name, canonicalUri);
       _libraryList.add(library);
       return library;
     });
   }
 
+  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);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _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;
     });
   }
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         int typeVariableIndex = _typeVariableList.length;
@@ skipping 851 matching lines @@
     throw new UnimplementedError('KernelClosedWorldMixin.getAppliedMixin');
   }
 
   @override
   Iterable<ClassEntity> getInterfaces(ClassEntity cls) {
     throw new UnimplementedError('KernelClosedWorldMixin.getInterfaces');
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorldMixin.getSuperClass');
+    return elementMap._getSuperType(cls)?.element;
   }
 
   @override
   int getHierarchyDepth(ClassEntity cls) {
     return elementMap._getHierarchyDepth(cls);
   }
 
   @override
   OrderedTypeSet getOrderedTypeSet(ClassEntity cls) {
     return elementMap._getOrderedTypeSet(cls);
@@ skipping 49 matching lines @@
             allTypedefs,
             mixinUses,
             typesImplementedBySubclasses,
             classHierarchyNodes,
             classSets) {
     computeRtiNeed(resolutionWorldBuilder, rtiNeedBuilder,
         enableTypeAssertions: options.enableTypeAssertions);
   }
 
   @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;
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
 
   WorldDeconstructionForTesting(this.elementMap);
 
   IndexedClass getSuperclassForClass(IndexedClass cls) {
@@ skipping 300 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }