Assert that we don't mix K and J elements

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,
         MixinApplicationElement,
         TypedefElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
 import 'js_backend/backend_usage.dart' show BackendUsage;
 import 'js_backend/interceptor_data.dart' show InterceptorData;
 import 'js_backend/native_data.dart' show NativeData;
+import 'js_backend/runtime_types.dart'
+    show RuntimeTypesNeed, RuntimeTypesNeedBuilder;
 import 'ordered_typeset.dart';
+import 'options.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
 import 'universe/function_set.dart' show FunctionSet;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
+import 'universe/world_builder.dart';
 import 'util/util.dart' show Link;
 
 /// Common superinterface for [OpenWorld] and [ClosedWorld].
 abstract class World {}
 
 /// The [ClosedWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
 /// it, what functions are called, what classes are allocated, which native
@@ skipping 10 matching lines @@
   ElementEnvironment get elementEnvironment;
 
   DartTypes get dartTypes;
 
   CommonElements get commonElements;
 
   CommonMasks get commonMasks;
 
   ConstantSystem get constantSystem;
 
+  RuntimeTypesNeed get rtiNeed;
+
+  Iterable<ClassEntity> get liveNativeClasses;
+
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassEntity cls);
 
   /// Returns `true` if [cls] is directly instantiated. This means that at
   /// runtime instances of exactly [cls] are assumed to exist.
   bool isDirectlyInstantiated(ClassEntity cls);
 
   /// Returns `true` if [cls] is abstractly instantiated. This means that at
   /// runtime instances of [cls] or unknown subclasses of [cls] are assumed to
   /// exist.
@@ skipping 373 matching lines @@
   final CommonElements commonElements;
 
   // TODO(johnniwinther): Can this be derived from [ClassSet]s?
   final Set<ClassEntity> _implementedClasses;
 
   final Iterable<MemberEntity> liveInstanceMembers;
 
   /// Members that are written either directly or through a setter selector.
   final Iterable<MemberEntity> assignedInstanceMembers;
 
+  final Iterable<ClassEntity> liveNativeClasses;
+
   ClosedWorldBase(
       this.elementEnvironment,
       this.dartTypes,
       this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       Set<ClassEntity> implementedClasses,
+      this.liveNativeClasses,
       this.liveInstanceMembers,
       this.assignedInstanceMembers,
       Set<TypedefElement> allTypedefs,
       this.mixinUses,
       this.typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets)
       : this._implementedClasses = implementedClasses,
         this._allTypedefs = allTypedefs,
         this._classHierarchyNodes = classHierarchyNodes,
@@ skipping 687 matching lines @@
       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();
   }
 }
 
-class ClosedWorldImpl extends ClosedWorldBase {
+class ClosedWorldImpl extends ClosedWorldBase with ClosedWorldRtiNeedMixin {
   ClosedWorldImpl(
-      {ElementEnvironment elementEnvironment,
+      {CompilerOptions options,
+      ElementEnvironment elementEnvironment,
       DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
+      ResolutionWorldBuilder resolutionWorldBuilder,
+      RuntimeTypesNeedBuilder rtiNeedBuilder,
       Set<ClassEntity> implementedClasses,
+      Iterable<ClassEntity> liveNativeClasses,
       Iterable<MemberEntity> liveInstanceMembers,
       Iterable<MemberEntity> assignedInstanceMembers,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             elementEnvironment,
             dartTypes,
             commonElements,
             constantSystem,
             nativeData,
             interceptorData,
             backendUsage,
             implementedClasses,
+            liveNativeClasses,
             liveInstanceMembers,
             assignedInstanceMembers,
             allTypedefs,
             mixinUses,
             typesImplementedBySubclasses,
             classHierarchyNodes,
-            classSets);
+            classSets) {
+    computeRtiNeed(resolutionWorldBuilder, rtiNeedBuilder,
+        enableTypeAssertions: options.enableTypeAssertions);
+  }
 
   bool checkClass(ClassElement cls) => cls.isDeclaration;
 
   bool checkEntity(Element element) => element.isDeclaration;
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     assert(cls.isDeclaration, failedAt(cls, '$cls must be the declaration.'));
     assert(cls.isResolved, failedAt(cls, '$cls must be resolved.'));
 
     // TODO(johnniwinther): Reinsert this or similar invariant. Currently
@@ skipping 95 matching lines @@
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return super.getSideEffectsOfElement(element);
   }
 }
+
+abstract class ClosedWorldRtiNeedMixin implements ClosedWorld {
+  RuntimeTypesNeed _rtiNeed;
+
+  void computeRtiNeed(ResolutionWorldBuilder resolutionWorldBuilder,
+      RuntimeTypesNeedBuilder rtiNeedBuilder,
+      {bool enableTypeAssertions}) {
+    _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
+        resolutionWorldBuilder, this,
+        enableTypeAssertions: enableTypeAssertions);
+  }
+
+  RuntimeTypesNeed get rtiNeed => _rtiNeed;
+}