Register created closure class with the world.

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 'closure.dart' show ClosureClassElement;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
         MethodElement,
@@ skipping 351 matching lines @@
   bool getCurrentlyKnownMightBePassedToApply(FunctionEntity element);
 
   /// Registers that [element] is called in a loop.
   // 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.
-  void registerClosureClass(covariant ClassElement cls);
+  /// 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);
 }
 
 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 780 matching lines @@
     StringBuffer sb = new StringBuffer();
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
     getClassHierarchyNode(commonElements.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
+
+  /// Should only be called by subclasses.
+  void addClassHierarchyNode(ClassEntity cls, ClassHierarchyNode node) {
+    _classHierarchyNodes[cls] = node;
+  }
+
+  /// Should only be called by subclasses.
+  void addClassSet(ClassEntity cls, ClassSet classSet) {
+    _classSets[cls] = classSet;
+  }
 }
 
 class ClosedWorldImpl extends ClosedWorldBase with ClosedWorldRtiNeedMixin {
   ClosedWorldImpl(
       {CompilerOptions options,
       ElementEnvironment elementEnvironment,
       DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
@@ skipping 99 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(ClosureClassElement cls) {
+  void registerClosureClass(ClassElement cls, bool _) {
     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;
 }