Check equivalence of closed world based on kernel elements.

pkg/compiler/lib/src/universe/element_world_builder.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.
 
 part of world_builder;
 
 /// [ResolutionEnqueuerWorldBuilder] based on the [Element] model.
 class ElementResolutionWorldBuilder extends ResolutionWorldBuilderBase {
   /// Used for testing the new more precise computation of instantiated types
   /// and classes.
@@ skipping 88 matching lines @@
   _ClassUsage _createClassUsage(ClassElement cls) {
     cls.ensureResolved(_resolution);
     _resolution.ensureClassMembers(cls);
     return super._createClassUsage(cls);
   }
 
   /// 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(ClassEntity cls) => _registerClass(cls);
+  void registerClass(ClassElement cls) => _registerClass(cls.declaration);
 
   void _registerClass(ClassEntity cls, {bool isDirectlyInstantiated: false}) {
     _ensureClassSet(cls);
     if (isDirectlyInstantiated) {
       _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
     }
   }
 
   void _processInstantiatedClassMember(
       ClassEntity cls, MemberElement member, MemberUsedCallback memberUsed) {
     assert(invariant(member, member.isDeclaration));
     member.computeType(_resolution);
     super._processInstantiatedClassMember(cls, member, memberUsed);
   }
 
-  ClassHierarchyNode _ensureClassHierarchyNode(ClassElement cls) {
-    cls = cls.declaration;
-    return _classHierarchyNodes.putIfAbsent(cls, () {
-      ClassHierarchyNode parentNode;
-      if (cls.superclass != null) {
-        parentNode = _ensureClassHierarchyNode(cls.superclass);
-      }
-      return new ClassHierarchyNode(parentNode, cls, cls.hierarchyDepth);
-    });
+  @override
+  ClassEntity getAppliedMixin(ClassElement cls) {
+    if (cls.isMixinApplication) {
+      MixinApplicationElement mixinApplication = cls;
+      // Note: If [mixinApplication] is malformed [mixin] is `null`.
+      return mixinApplication.mixin;
+    }
+    return null;
   }
 
-  ClassSet _ensureClassSet(ClassElement cls) {
-    cls = cls.declaration;
-    return _classSets.putIfAbsent(cls, () {
-      ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
-      ClassSet classSet = new ClassSet(node);
+  @override
+  int getHierarchyDepth(ClassElement cls) => cls.hierarchyDepth;
 
-      for (ResolutionInterfaceType type in cls.allSupertypes) {
-        // TODO(johnniwinther): Optimization: Avoid adding [cls] to
-        // superclasses.
-        ClassSet subtypeSet = _ensureClassSet(type.element);
-        subtypeSet.addSubtype(node);
-      }
-      if (cls.isMixinApplication) {
-        // TODO(johnniwinther): Store this in the [ClassSet].
-        MixinApplicationElement mixinApplication = cls;
-        if (mixinApplication.mixin != null) {
-          // If [mixinApplication] is malformed [mixin] is `null`.
-          registerMixinUse(mixinApplication, mixinApplication.mixin);
-        }
-      }
+  @override
+  bool checkClass(ClassElement cls) => cls.isDeclaration;
 
-      return classSet;
-    });
-  }
+  @override
+  bool validateClass(ClassElement cls) => cls.isResolved;
 
-  void _updateSuperClassHierarchyNodeForClass(ClassHierarchyNode node) {
-    // Ensure that classes implicitly implementing `Function` are in its
-    // subtype set.
-    ClassElement cls = node.cls;
-    if (cls != _commonElements.functionClass &&
-        cls.implementsFunction(_commonElements)) {
-      ClassSet subtypeSet = _ensureClassSet(_commonElements.functionClass);
-      subtypeSet.addSubtype(node);
-    }
-    if (!node.isInstantiated && node.parentNode != null) {
-      _updateSuperClassHierarchyNodeForClass(node.parentNode);
-    }
-  }
+  @override
+  bool implementsFunction(ClassElement cls) =>
+      cls.implementsFunction(_commonElements);
 
-  void _updateClassHierarchyNodeForClass(ClassElement cls,
-      {bool directlyInstantiated: false, bool abstractlyInstantiated: false}) {
-    ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
-    _updateSuperClassHierarchyNodeForClass(node);
-    if (directlyInstantiated) {
-      node.isDirectlyInstantiated = true;
-    }
-    if (abstractlyInstantiated) {
-      node.isAbstractlyInstantiated = true;
-    }
-  }
+  @override
+  ClassEntity getSuperClass(ClassElement cls) => cls.superclass;
+
+  @override
+  Iterable<InterfaceType> getSupertypes(ClassElement cls) => cls.allSupertypes;
 
   ClosedWorld closeWorld() {
     Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses =
-        new Map<ClassEntity, Set<ClassEntity>>();
-
-    /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
-    /// properties of the [ClassHierarchyNode] for [cls].
-
-    void addSubtypes(ClassElement cls, InstantiationInfo info) {
-      if (!info.hasInstantiation) {
-        return;
-      }
-      assert(cls.isDeclaration);
-      if (!cls.isResolved) {
-        throw new SpannableAssertionFailure(
-            cls, 'Class "${cls.name}" is not resolved.');
-      }
-
-      _updateClassHierarchyNodeForClass(cls,
-          directlyInstantiated: info.isDirectlyInstantiated,
-          abstractlyInstantiated: info.isAbstractlyInstantiated);
-
-      // Walk through the superclasses, and record the types
-      // implemented by that type on the superclasses.
-      ClassElement superclass = cls.superclass;
-      while (superclass != null) {
-        Set<ClassEntity> typesImplementedBySubclassesOfCls =
-            typesImplementedBySubclasses.putIfAbsent(
-                superclass, () => new Set<ClassEntity>());
-        for (ResolutionInterfaceType current in cls.allSupertypes) {
-          typesImplementedBySubclassesOfCls.add(current.element);
-        }
-        superclass = superclass.superclass;
-      }
-    }
-
-    // Use the [:seenClasses:] set to include non-instantiated
-    // classes: if the superclass of these classes require RTI, then
-    // they also need RTI, so that a constructor passes the type
-    // variables to the super constructor.
-    forEachInstantiatedClass(addSubtypes);
-
+        populateHierarchyNodes();
     _closed = true;
     return _closedWorldCache = new ClosedWorldImpl(
         commonElements: _commonElements,
         constantSystem: _backend.constantSystem,
         nativeData: _backend.nativeData,
         interceptorData: _backend.interceptorData,
         backendUsage: _backend.backendUsage,
         resolutionWorldBuilder: this,
         functionSetBuilder: _allFunctions,
         allTypedefs: _allTypedefs,
         mixinUses: _mixinUses,
         typesImplementedBySubclasses: typesImplementedBySubclasses,
         classHierarchyNodes: _classHierarchyNodes,
         classSets: _classSets);
   }
 
   @override
   void registerMixinUse(
       MixinApplicationElement mixinApplication, ClassElement mixin) {
     assert(mixin.isDeclaration);
     super.registerMixinUse(mixinApplication, mixin);
   }
 }