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((t) {

[Siggi Cherem (dart-lang), 2017/09/01 19:05:12]

nit: isChecks.forEach(_classEnsurer.ensureClassesInType);

[Harry Terkelsen, 2017/09/01 21:48:57]

Done.

+      _classEnsurer.ensureClassesInType(t);
+    });
+    closurizedMembers.forEach((function) {

[Siggi Cherem (dart-lang), 2017/09/01 19:05:12]

I'm surprised we were missing so many here. This code path was also used in the
old compiler pipeline, how come it is not missing types for all of these as
well?

[Johnni Winther, 2017/09/01 19:59:56]

Because ClassElement.ensureResolved registers the class with the class
hierarchy.

[Harry Terkelsen, 2017/09/01 21:25:33]

The old pipeline adds classes to the hierarchy as it resolves them. This way
adds them based on the impacts after resolution.

+      _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 BaseDartTypeVisitor<void, Null>
+class _ClassEnsurer extends BaseDartTypeVisitor<dynamic, Null> {
+  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
+  visitInterfaceType(InterfaceType type, _) {
+    worldBuilder._ensureClassSet(type.element);
+    type.typeArguments.forEach((t) {
+      t.accept(this, null);
+    });
+  }
+}