Assert that we don't mix K and J elements

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;
 import '../common/resolution.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 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/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';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_map.dart';
 import 'element_map_mixins.dart';
 import 'elements.dart';
 import 'env.dart';
 import 'kelements.dart';
@@ skipping 49 matching lines @@
   List<MemberData> _memberData = <MemberData>[];
 
   KernelToElementMapBase(this.reporter, Environment environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this, environment);
     _typeConverter = new DartTypeConverter(this);
     _types = new _KernelDartTypes(this);
   }
 
+  bool checkFamily(Entity entity);
+
   DartTypes get types => _types;
 
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
   @override
   CommonElements get commonElements => _commonElements;
 
   FunctionEntity get _mainFunction {
     return _env.mainMethod != null ? _getMethod(_env.mainMethod) : null;
   }
 
   LibraryEntity get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
   Iterable<LibraryEntity> get _libraries;
 
   LibraryEntity lookupLibrary(Uri uri) {
     LibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   String _getLibraryName(IndexedLibrary library) {
+    assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     return libraryEnv.library.name ?? '';
   }
 
   MemberEntity lookupLibraryMember(IndexedLibrary library, String name,
       {bool setter: false}) {
+    assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   void _forEachLibraryMember(
       IndexedLibrary library, void f(MemberEntity member)) {
+    assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     libraryEnv.forEachMember((ir.Member node) {
       f(getMember(node));
     });
   }
 
   ClassEntity lookupClass(IndexedLibrary library, String name) {
+    assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
   void _forEachClass(IndexedLibrary library, void f(ClassEntity cls)) {
+    assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     libraryEnv.forEachClass((ClassEnv classEnv) {
       if (!classEnv.isUnnamedMixinApplication) {
         f(_getClass(classEnv.cls, classEnv));
       }
     });
   }
 
   MemberEntity lookupClassMember(IndexedClass cls, String name,
       {bool setter: false}) {
+    assert(checkFamily(cls));
     ClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   ConstructorEntity lookupConstructor(IndexedClass cls, String name) {
+    assert(checkFamily(cls));
     ClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupConstructor(name);
     return member != null ? getConstructor(member) : null;
   }
 
   @override
   InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
   }
 
   LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
 
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv libraryEnv]);
 
   @override
   ClassEntity getClass(ir.Class node) => _getClass(node);
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]);
 
   InterfaceType _getSuperType(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.supertype;
   }
 
   void _ensureThisAndRawType(ClassEntity cls, ClassData data) {
+    assert(checkFamily(cls));
     if (data.thisType == null) {
       ir.Class node = data.cls;
       // TODO(johnniwinther): Add the type argument to the list literal when we
       // no longer use resolution types.
       if (node.typeParameters.isEmpty) {
         data.thisType =
             data.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
       } else {
         data.thisType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .generate(node.typeParameters.length,
                 (int index) {
               return new TypeVariableType(
                   _getTypeVariable(node.typeParameters[index]));
             }));
         data.rawType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .filled(
                 node.typeParameters.length, const DynamicType()));
       }
     }
   }
 
   TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
       _getTypeVariable(node);
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node);
 
   void _ensureSupertypes(ClassEntity cls, ClassData data) {
+    assert(checkFamily(cls));
     if (data.orderedTypeSet == null) {
       _ensureThisAndRawType(cls, data);
 
       ir.Class node = data.cls;
 
       if (node.supertype == null) {
         data.orderedTypeSet = new OrderedTypeSet.singleton(data.thisType);
         data.isMixinApplication = false;
         data.interfaces = const <InterfaceType>[];
       } else {
@@ skipping 148 matching lines @@
       {bool requireConstant: true}) {
     return _constantEnvironment.getConstantValue(constant);
   }
 
   DartType _substByContext(DartType type, InterfaceType context) {
     return type.subst(
         context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getThisType(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureThisAndRawType(cls, data);
     return data.thisType;
   }
 
   InterfaceType _getRawType(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureThisAndRawType(cls, data);
     return data.rawType;
   }
 
   FunctionType _getFunctionType(IndexedFunction function) {
+    assert(checkFamily(function));
     FunctionData data = _memberData[function.memberIndex];
     return data.getFunctionType(this);
   }
 
   ClassEntity _getAppliedMixin(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.mixedInType?.element;
   }
 
   bool _isMixinApplication(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.isMixinApplication;
   }
 
   bool _isUnnamedMixinApplication(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
     return env.isUnnamedMixinApplication;
   }
 
   void _forEachSupertype(IndexedClass cls, void f(InterfaceType supertype)) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     data.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachMixin(IndexedClass cls, void f(ClassEntity mixin)) {
+    assert(checkFamily(cls));
     while (cls != null) {
       ClassData data = _classData[cls.classIndex];
       _ensureSupertypes(cls, data);
       if (data.mixedInType != null) {
         f(data.mixedInType.element);
       }
       cls = data.supertype?.element;
     }
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
+    assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachConstructor((ir.Member member) {
       f(getConstructor(member));
     });
   }
 
   void _forEachClassMember(
       IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
+    assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     if (data.supertype != null) {
       _forEachClassMember(data.supertype.element, f);
     }
   }
 
   ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
+    assert(checkFamily(constructor));
     ConstructorData data = _memberData[constructor.memberIndex];
     return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(IndexedField field) {
+    assert(checkFamily(field));
     FieldData data = _memberData[field.memberIndex];
     return data.getFieldConstant(this, field);
   }
 
   InterfaceType _asInstanceOf(InterfaceType type, ClassEntity cls) {
+    assert(checkFamily(cls));
     OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
     InterfaceType supertype =
         orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
     if (supertype != null) {
       supertype = _substByContext(supertype, type);
     }
     return supertype;
   }
 
   OrderedTypeSet _getOrderedTypeSet(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.orderedTypeSet;
   }
 
   int _getHierarchyDepth(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.orderedTypeSet.maxDepth;
   }
 
   Iterable<InterfaceType> _getInterfaces(IndexedClass cls) {
+    assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
   ir.Member _getMemberNode(covariant IndexedMember member) {
+    assert(checkFamily(member));
     return _memberData[member.memberIndex].node;
   }
 
   ir.Class _getClassNode(covariant IndexedClass cls) {
+    assert(checkFamily(cls));
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase] by
 /// creating K-model elements.
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
@@ skipping 447 matching lines @@
 // [JsStrategy] is the default.
 class KernelToElementMapForImpactImpl2 extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
         KernelToElementMapForImpactImpl,
         ElementCreatorMixin,
         KElementCreatorMixin {
   KernelToElementMapForImpactImpl2(
       DiagnosticReporter reporter, Environment environment)
       : super(reporter, environment);
+
+  @override
+  bool checkFamily(Entity entity) {
+    assert(
+        '$entity'.startsWith(kElementPrefix),
+        failedAt(entity,
+            "Unexpected entity $entity, expected family $kElementPrefix."));
+    return true;
+  }
 }
 
 abstract class KernelToElementMapForBuildingFromBaseMixin
     implements KernelToElementMapForBuilding, KernelToElementMapBase {
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     // TODO(johnniwinther): Cache the result in [FieldData].
     return getConstantValue(field.initializer,
         requireConstant: field.isConst, implicitNull: !field.isConst);
   }
@@ skipping 25 matching lines @@
     with
         KernelToElementMapForBuildingMixin,
         KernelToElementMapForBuildingFromBaseMixin,
         ElementCreatorMixin,
         KElementCreatorMixin
     implements KernelToWorldBuilder {
   KernelToElementMapForBuildingImpl(
       DiagnosticReporter reporter, Environment environment)
       : super(reporter, environment);
 
+  @override
+  bool checkFamily(Entity entity) {
+    assert(
+        '$entity'.startsWith(kElementPrefix),
+        failedAt(entity,
+            "Unexpected entity $entity, expected family $kElementPrefix."));
+    return true;
+  }
+
   ConstantEnvironment get constantEnvironment => _constantEnvironment;
 
   ir.Library getKernelLibrary(KLibrary entity) =>
       _libraryEnvs[entity.libraryIndex].library;
 
   ir.Class getKernelClass(KClass entity) => _classEnvs[entity.classIndex].cls;
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
@@ skipping 386 matching lines @@
   @override
   String readFromEnvironment(String name) {
     return _environment.valueOf(name);
   }
 }
 
 class KernelResolutionWorldBuilder extends KernelResolutionWorldBuilderBase {
   final KernelToElementMapForImpactImpl elementMap;
 
   KernelResolutionWorldBuilder(
+      CompilerOptions options,
       this.elementMap,
       NativeBasicData nativeBasicData,
       NativeDataBuilder nativeDataBuilder,
       InterceptorDataBuilder interceptorDataBuilder,
       BackendUsageBuilder backendUsageBuilder,
+      RuntimeTypesNeedBuilder rtiNeedBuilder,
+      NativeResolutionEnqueuer nativeResolutionEnqueuer,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
       : super(
+            options,
             elementMap.elementEnvironment,
             elementMap.types,
             elementMap.commonElements,
             elementMap._constantEnvironment.constantSystem,
             nativeBasicData,
             nativeDataBuilder,
             interceptorDataBuilder,
             backendUsageBuilder,
+            rtiNeedBuilder,
+            nativeResolutionEnqueuer,
             selectorConstraintsStrategy);
 
   @override
   Iterable<InterfaceType> getSupertypes(ClassEntity cls) {
     return elementMap._getOrderedTypeSet(cls).supertypes;
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
     return elementMap._getSuperType(cls)?.element;
@@ skipping 81 matching lines @@
   bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) =>
       true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 
   @override
   bool checkEntity(Entity element) => true;
 }
 
-class KernelClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
+class KernelClosedWorld extends ClosedWorldBase
+    with KernelClosedWorldMixin, ClosedWorldRtiNeedMixin {
   final KernelToElementMapForImpactImpl elementMap;
 
   KernelClosedWorld(this.elementMap,
-      {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);
+  }
 
   @override
   void registerClosureClass(ClassElement cls) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
@@ skipping 181 matching lines @@
         _constructorMap[data.node] = newMember;
       } else {
         _methodMap[data.node] = newMember;
       }
     }
     for (int typeVariableIndex = 0;
         typeVariableIndex < _elementMap._typeVariableList.length;
         typeVariableIndex++) {}
   }
 
+  @override
+  bool checkFamily(Entity entity) {
+    assert(
+        '$entity'.startsWith(jsElementPrefix),
+        failedAt(entity,
+            "Unexpected entity $entity, expected family $jsElementPrefix."));
+    return true;
+  }
+
   JsToFrontendMap get jsToFrontendMap => _jsToFrontendMap;
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _getSpannable(member, node);
   }
 
   Iterable<LibraryEntity> get _libraries {
     return _libraryMap.values;
   }
@@ skipping 43 matching lines @@
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
 }