Less inequivalence on Hello 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 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 524 matching lines @@
 
   void _ensureSupertypes(KClass cls, _KClassEnv env) {
     if (env.orderedTypeSet == null) {
       _ensureThisAndRawType(cls, env);
 
       ir.Class node = env.cls;
 
       if (node.supertype == null) {
         env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
         env.isMixinApplication = false;
+        env.interfaces = const <InterfaceType>[];
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
           InterfaceType type = _typeConverter.visitSupertype(node);
           KClass superclass = type.element;
           _KClassEnv env = _classEnvs[superclass.classIndex];
           _ensureSupertypes(superclass, env);
           return type;
         }
 
         env.supertype = processSupertype(node.supertype);
         LinkBuilder<InterfaceType> linkBuilder =
             new LinkBuilder<InterfaceType>();
         if (node.mixedInType != null) {
           env.isMixinApplication = true;
           linkBuilder
               .addLast(env.mixedInType = processSupertype(node.mixedInType));
         } else {
           env.isMixinApplication = false;
         }
         node.implementedTypes.forEach((ir.Supertype supertype) {
           linkBuilder.addLast(processSupertype(supertype));
         });
         Link<InterfaceType> interfaces = linkBuilder.toLink();
         OrderedTypeSetBuilder setBuilder =
             new _KernelOrderedTypeSetBuilder(this, cls);
         env.orderedTypeSet =
             setBuilder.createOrderedTypeSet(env.supertype, interfaces);
+        env.interfaces = new List<InterfaceType>.from(interfaces.toList());
       }
     }
   }
 
   OrderedTypeSet _getOrderedTypeSet(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.orderedTypeSet;
   }
 
@@ skipping 25 matching lines @@
     _ensureSupertypes(cls, env);
     return env.isMixinApplication;
   }
 
   bool _isUnnamedMixinApplication(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.isUnnamedMixinApplication;
   }
 
+  Iterable<InterfaceType> _getInterfaces(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.interfaces;
+  }
+
   void _forEachSupertype(KClass cls, void f(InterfaceType supertype)) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     env.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachMixin(KClass cls, void f(ClassEntity mixin)) {
     while (cls != null) {
       _KClassEnv env = _classEnvs[cls.classIndex];
       _ensureSupertypes(cls, env);
@@ skipping 290 matching lines @@
 /// Environment for fast lookup of class members.
 class _KClassEnv {
   final ir.Class cls;
   bool isMixinApplication;
   final bool isUnnamedMixinApplication;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   InterfaceType mixedInType;
+  List<InterfaceType> interfaces;
   OrderedTypeSet orderedTypeSet;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
   Iterable<ConstantValue> _metadata;
 
   _KClassEnv(this.cls)
       // TODO(johnniwinther): Change this to use a property on [cls] when such
@@ skipping 604 matching lines @@
 
   KernelResolutionWorldBuilder(
       this.elementMap,
       NativeBasicData nativeBasicData,
       NativeDataBuilder nativeDataBuilder,
       InterceptorDataBuilder interceptorDataBuilder,
       BackendUsageBuilder backendUsageBuilder,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
       : super(
             elementMap.elementEnvironment,
+            elementMap.types,
             elementMap.commonElements,
             elementMap._constantEnvironment.constantSystem,
             nativeBasicData,
             nativeDataBuilder,
             interceptorDataBuilder,
             backendUsageBuilder,
             selectorConstraintsStrategy);
 
   @override
   Iterable<InterfaceType> getSupertypes(ClassEntity cls) {
@@ skipping 26 matching lines @@
 
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
 class KernelClosedWorld extends ClosedWorldBase {
   final KernelToElementMapImpl _elementMap;
 
   KernelClosedWorld(this._elementMap,
       {ElementEnvironment elementEnvironment,
+      DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
       FunctionSet functionSet,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             elementEnvironment: elementEnvironment,
+            dartTypes: dartTypes,
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
             implementedClasses: implementedClasses,
             functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
@@ skipping 285 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }