Handle instance/super methods in js_model/model_test

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;
@@ skipping 390 matching lines @@
   /// are included.
   SUBTYPE,
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final ConstantSystem constantSystem;
   final NativeData nativeData;
   final InterceptorData interceptorData;
   final BackendUsage backendUsage;
 
-  final FunctionSet _allFunctions;
+  FunctionSet _allFunctions;
 
   final Set<TypedefElement> _allTypedefs;
 
-  final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
+  final Map<ClassEntity, Set<ClassEntity>> mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
   final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
   final Map<ClassEntity, ClassSet> _classSets;
 
   final Map<ClassEntity, Map<ClassEntity, bool>> _subtypeCoveredByCache =
@@ skipping 17 matching lines @@
   final ElementEnvironment elementEnvironment;
   final DartTypes dartTypes;
   final CommonElements commonElements;
 
   // TODO(johnniwinther): Avoid this.
   final ResolutionWorldBuilder _resolverWorld;
 
   // TODO(johnniwinther): Can this be derived from [ClassSet]s?
   final Set<ClassEntity> _implementedClasses;
 
+  final Iterable<MemberEntity> liveInstanceMembers;
+
   ClosedWorldBase(
-      {this.elementEnvironment,
+      this.elementEnvironment,

[Siggi Cherem (dart-lang), 2017/07/05 20:28:52]

since we loose named arguments because of the new mixin, I wonder whether it is
worth it.

What if we include the default implementation here instead?

It is technically still correct and the Impl subclass below can still override
it so that it is optimized for the regular modelx element model.

[Johnni Winther, 2017/07/06 14:14:46]

I want required named arguments - bad language!

       this.dartTypes,
       this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
-      FunctionSet functionSet,
+      this.liveInstanceMembers,

[Siggi Cherem (dart-lang), 2017/07/05 20:28:52]

any reason why not create the FunctionSet eagerly here?

[Johnni Winther, 2017/07/06 14:14:46]

Yes. [FunctionSet] is created lazily because it is not used when we switch from
a frontend to a backend model before inference. Add a comment.

       Set<TypedefElement> allTypedefs,
-      Map<ClassEntity, Set<ClassEntity>> mixinUses,
+      this.mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
-      Map<ClassEntity, ClassSet> classSets})
+      Map<ClassEntity, ClassSet> classSets)
       : this._resolverWorld = resolutionWorldBuilder,
         this._implementedClasses = implementedClasses,
-        this._allFunctions = functionSet,
         this._allTypedefs = allTypedefs,
-        this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
   }
 
   @override
   ClosedWorld get closedWorld => this;
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
@@ skipping 450 matching lines @@
         if (common.contains(interface)) return false;
       }
       return true;
     });
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<ClassEntity> mixinUsesOf(ClassEntity cls) {
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassEntity, List<ClassEntity>>();
-      for (ClassEntity mixin in _mixinUses.keys) {
+      for (ClassEntity mixin in mixinUses.keys) {
         List<ClassEntity> uses = <ClassEntity>[];
 
         void addLiveUse(ClassEntity mixinApplication) {
           if (isInstantiated(mixinApplication)) {
             uses.add(mixinApplication);
           } else if (isNamedMixinApplication(mixinApplication)) {
-            Set<ClassEntity> next = _mixinUses[mixinApplication];
+            Set<ClassEntity> next = mixinUses[mixinApplication];
             if (next != null) {
               next.forEach(addLiveUse);
             }
           }
         }
 
-        _mixinUses[mixin].forEach(addLiveUse);
+        mixinUses[mixin].forEach(addLiveUse);
         if (uses.isNotEmpty) {
           _liveMixinUses[mixin] = uses;
         }
       }
     }
     Iterable<ClassEntity> uses = _liveMixinUses[cls];
     return uses != null ? uses : const <ClassEntity>[];
   }
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
@@ skipping 34 matching lines @@
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassEntity cls) {
     assert(checkClass(cls));
     return _classSets[cls];
   }
 
   Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
+  void _ensureFunctionSet() {
+    if (_allFunctions == null) {
+      _allFunctions = new FunctionSet(liveInstanceMembers);
+    }
+  }
+
   TypeMask computeReceiverType(Selector selector, TypeMask mask) {
+    _ensureFunctionSet();
     return _allFunctions.receiverType(selector, mask, this);
   }
 
   Iterable<MemberEntity> locateMembers(Selector selector, TypeMask mask) {
+    _ensureFunctionSet();
     return _allFunctions.filter(selector, mask, this);
   }
 
   bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
+    _ensureFunctionSet();
     return _allFunctions
         .filter(selector, mask, this)
         .any((each) => each.isGetter);
   }
 
   FieldEntity locateSingleField(Selector selector, TypeMask mask) {
     MemberEntity result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
@@ skipping 28 matching lines @@
       return !_resolverWorld.hasInvokedSetter(element) &&
           !_resolverWorld.fieldSetters.contains(element);
     }
     return false;
   }
 
   SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask) {
     // We're not tracking side effects of closures.
     if (selector.isClosureCall) return new SideEffects();
     SideEffects sideEffects = new SideEffects.empty();
+    _ensureFunctionSet();
     for (MemberEntity e in _allFunctions.filter(selector, mask, this)) {
       if (e.isField) {
         if (selector.isGetter) {
           if (!fieldNeverChanges(e)) {
             sideEffects.setDependsOnInstancePropertyStore();
           }
         } else if (selector.isSetter) {
           sideEffects.setChangesInstanceProperty();
         } else {
           assert(selector.isCall);
@@ skipping 85 matching lines @@
   ClosedWorldImpl(
       {ElementEnvironment elementEnvironment,
       DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
-      FunctionSet functionSet,
+      Iterable<MemberEntity> liveInstanceMembers,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
-            elementEnvironment: elementEnvironment,
-            dartTypes: dartTypes,
-            commonElements: commonElements,
-            constantSystem: constantSystem,
-            nativeData: nativeData,
-            interceptorData: interceptorData,
-            backendUsage: backendUsage,
-            resolutionWorldBuilder: resolutionWorldBuilder,
-            implementedClasses: implementedClasses,
-            functionSet: functionSet,
-            allTypedefs: allTypedefs,
-            mixinUses: mixinUses,
-            typesImplementedBySubclasses: typesImplementedBySubclasses,
-            classHierarchyNodes: classHierarchyNodes,
-            classSets: classSets);
+            elementEnvironment,
+            dartTypes,
+            commonElements,
+            constantSystem,
+            nativeData,
+            interceptorData,
+            backendUsage,
+            resolutionWorldBuilder,
+            implementedClasses,
+            liveInstanceMembers,
+            allTypedefs,
+            mixinUses,
+            typesImplementedBySubclasses,
+            classHierarchyNodes,
+            classSets);
 
   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);
   }
 }