Late creation of CodegenEnqueuer

pkg/compiler/lib/src/js_backend/interceptor_data.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 js_backend.interceptor_data;
 
 import '../common/names.dart' show Identifiers;
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
+import '../elements/types.dart';
 import '../js/js.dart' as jsAst;
 import '../types/types.dart' show TypeMask;
 import '../universe/selector.dart';
 import '../world.dart' show ClosedWorld;
 import 'backend_helpers.dart';
 import 'namer.dart';
 import 'native_data.dart';
 
 abstract class InterceptorData {
   /// Returns `true` if [cls] is an intercepted class.
   bool isInterceptedClass(ClassEntity element);
 
   bool isInterceptedMethod(MemberEntity element);
   bool fieldHasInterceptedGetter(FieldEntity element);
   bool fieldHasInterceptedSetter(FieldEntity element);
   bool isInterceptedName(String name);
   bool isInterceptedSelector(Selector selector);
   bool isInterceptedMixinSelector(Selector selector, TypeMask mask);
   Iterable<ClassEntity> get interceptedClasses;
   bool isMixedIntoInterceptedClass(ClassEntity element);
 
   /// Returns a set of interceptor classes that contain a member named [name]
   ///
   /// Returns an empty set if there is no class. Do not modify the returned set.
   Set<ClassEntity> getInterceptedClassesOn(String name);
+
+  bool mayGenerateInstanceofCheck(DartType type);

[Siggi Cherem (dart-lang), 2017/03/14 03:18:18]

+dartdoc:
/// Whether the compiler can use the native `instanceof`check to test for
/// instances of [type]. This is true for types that are not used as mixins or
interfaces.

[Johnni Winther, 2017/03/15 09:49:01]

Done.

 }
 
 abstract class InterceptorDataBuilder {
   void addInterceptors(ClassEntity cls);
   void addInterceptorsForNativeClassMembers(ClassEntity cls);
   InterceptorData onResolutionComplete(ClosedWorld closedWorld);
 }
 
 class InterceptorDataImpl implements InterceptorData {
   final NativeData _nativeData;
@@ skipping 143 matching lines @@
     if (_nativeData.isNativeOrExtendsNative(element)) return true;
     if (interceptedClasses.contains(element)) return true;
     if (_classesMixedIntoInterceptedClasses.contains(element)) return true;
     return false;
   }
 
   bool isMixedIntoInterceptedClass(ClassElement element) =>
       _classesMixedIntoInterceptedClasses.contains(element);
 
   Iterable<ClassElement> get interceptedClasses => _interceptedClasses;
+
+  bool mayGenerateInstanceofCheck(DartType type) {
+    // We can use an instanceof check for raw types that have no subclass that
+    // is mixed-in or in an implements clause.
+
+    if (!type.treatAsRaw) return false;
+    InterfaceType interfaceType = type;
+    ClassEntity classElement = interfaceType.element;
+    if (isInterceptedClass(classElement)) return false;
+    return _closedWorld.hasOnlySubclasses(classElement);
+  }
 }
 
 class InterceptorDataBuilderImpl implements InterceptorDataBuilder {
   final NativeData _nativeData;
   final BackendHelpers _helpers;
   final CommonElements _commonElements;
 
   /// The members of instantiated interceptor classes: maps a member name to the
   /// list of members that have that name. This map is used by the codegen to
   /// know whether a send must be intercepted or not.
@@ skipping 105 matching lines @@
     jsAst.Name name = namer.nameForGetInterceptor(classes);
     if (classes.contains(_helpers.jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       _specializedGetInterceptors[name] = _interceptorData.interceptedClasses;
     } else {
       _specializedGetInterceptors[name] = classes;
     }
   }
 }