Add types referenced in is-checks to the class hierarchy

pkg/compiler/lib/src/universe/resolution_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;
 
 abstract class ResolutionWorldBuilder implements WorldBuilder, OpenWorld {
   /// Set of all local functions in the program. Used by the mirror tracking
   /// system to find all live closure instances.
   Iterable<Local> get localFunctions;
@@ skipping 301 matching lines @@
 
   /// Map containing instance methods of live classes that are not yet
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
   /// Fields set.
   final Set<FieldEntity> fieldSetters = new Set<FieldEntity>();
   final Set<DartType> isChecks = new Set<DartType>();
 
+  _ClassEnsurer _classEnsurer;
+
   /// Set of all closures in the program. Used by the mirror tracking system
   /// to find all live closure instances.
   final Set<Local> localFunctions = new Set<Local>();
 
   /// Set of live local functions (closures) whose signatures reference type
   /// variables.
   ///
   /// A local function is considered live if the enclosing member function is
   /// live.
   final Set<Local> localFunctionsWithFreeTypeVariables = new Set<Local>();
@@ skipping 53 matching lines @@
       this._elementEnvironment,
       this._dartTypes,
       this._commonElements,
       this._constantSystem,
       this._nativeBasicData,
       this._nativeDataBuilder,
       this._interceptorDataBuilder,
       this._backendUsageBuilder,
       this._rtiNeedBuilder,
       this._nativeResolutionEnqueuer,
-      this.selectorConstraintsStrategy);
+      this.selectorConstraintsStrategy) {
+    _classEnsurer = new _ClassEnsurer(this);
+  }
 
   Iterable<ClassEntity> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   bool isMemberProcessed(MemberEntity member) =>
       _processedMembers.contains(member);
   void registerProcessedMember(MemberEntity member) {
     _processedMembers.add(member);
   }
 
@@ skipping 531 matching lines @@
         superclass = getSuperClass(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);
 
+    instantiatedTypes.forEach((type) {
+      var callType = _dartTypes.getCallType(type);
+      if (callType != null) {
+        _classEnsurer.ensureClassesInType(callType);
+      }
+    });
+    localFunctions.forEach((function) {
+      _classEnsurer.ensureClassesInType(
+          _elementEnvironment.getLocalFunctionType(function));
+    });
+    isChecks.forEach(_classEnsurer.ensureClassesInType);
+    closurizedMembers.forEach((function) {
+      _classEnsurer
+          .ensureClassesInType(_elementEnvironment.getFunctionType(function));
+    });
+
     _classHierarchyNodes.keys.toList().forEach(_ensureClassSet);
 
     return typesImplementedBySubclasses;
   }
 
   Iterable<MemberEntity> computeAssignedInstanceMembers() {
     Set<MemberEntity> assignedInstanceMembers = new Set<MemberEntity>();
     for (MemberEntity instanceMember in _liveInstanceMembers) {
       if (hasInvokedSetter(instanceMember)) {
         assignedInstanceMembers.add(instanceMember);
@@ skipping 66 matching lines @@
         typesImplementedBySubclasses: typesImplementedBySubclasses,
         classHierarchyNodes: _classHierarchyNodes,
         classSets: _classSets);
   }
 
   @override
   void registerClass(ClassEntity cls) {
     throw new UnimplementedError('KernelResolutionWorldBuilder.registerClass');
   }
 }
+
+// TODO(het): Make this have a type of BaseResolutionDartTypeVisitor<void, Null>
+class _ClassEnsurer extends BaseResolutionDartTypeVisitor<dynamic, Null> {

[Siggi Cherem (dart-lang), 2017/09/05 18:20:33]

consider adding a second TODO: to explain why you need "Resolution" here (to
deal with MalformedTypes) and that we would like to switch to just use the
regular visitor instead.

One way to do that might be to explicitly model malformed types in the entity
model as well in the future

[Harry Terkelsen, 2017/09/05 18:31:11]

Done.

+  final ResolutionWorldBuilderBase worldBuilder;
+
+  _ClassEnsurer(this.worldBuilder);
+
+  void ensureClassesInType(DartType type) {
+    type.accept(this, null);
+  }
+
+  @override
+  visitType(DartType type, _) {}
+
+  @override
+  visitFunctionType(FunctionType type, _) {
+    type.returnType.accept(this, null);
+    type.parameterTypes.forEach((t) {
+      t.accept(this, null);
+    });
+    type.optionalParameterTypes.forEach((t) {
+      t.accept(this, null);
+    });
+    type.namedParameterTypes.forEach((t) {
+      t.accept(this, null);
+    });
+  }
+//
+//  @override
+//  visitGenericType(GenericType type, _) {

[Siggi Cherem (dart-lang), 2017/09/05 18:20:33]

delete?

[Harry Terkelsen, 2017/09/05 18:31:11]

Done.

+//    type.typeArguments.forEach((t) {
+//      t.accept(this, null);
+//    });
+//  }
+
+  @override
+  visitInterfaceType(InterfaceType type, _) {
+    worldBuilder._ensureClassSet(type.element);
+    type.typeArguments.forEach((t) {
+      t.accept(this, null);
+    });
+  }
+
+  @override
+  visitTypedefType(TypedefType type, _) {
+    type.typeArguments.forEach((t) {
+      t.accept(this, null);
+    });
+    var functionType =
+        worldBuilder._elementEnvironment.getFunctionTypeOfTypedef(type.element);
+    functionType.accept(this, null);
+  }
+}