Version 2.19.0-401.0.dev

Merge 271f724 into dev

Author: Dart CI

pkg/compiler/lib/src/js_model/element_map_impl.dart

@@ -128,6 +128,7 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
       this._environment,
       KernelToElementMap _elementMap,
       Map<MemberEntity, MemberUsage> liveMemberUsage,
+      Set<MemberEntity> liveAbstractMembers,
       AnnotationsData annotations)
       : this.options = _elementMap.options {
     _elementEnvironment = JsElementEnvironment(this);
@@ -165,7 +166,7 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
       IndexedClass newClass = JClass(newLibrary as JLibrary, oldClass.name,
           isAbstract: oldClass.isAbstract);
       JClassEnv newEnv = env.convert(_elementMap, liveMemberUsage,
-          (ir.Library library) => libraryMap[library]!);
+          liveAbstractMembers, (ir.Library library) => libraryMap[library]!);
       classMap[env.cls] = classes.register(newClass, data.convert(), newEnv);
       assert(newClass.classIndex == oldClass.classIndex);
       libraries.getEnv(newLibrary).registerClass(newClass.name, newEnv);
@@ -176,7 +177,7 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
         memberIndex++) {
       IndexedMember oldMember = _elementMap.members.getEntity(memberIndex)!;
       MemberUsage? memberUsage = liveMemberUsage[oldMember];
-      if (memberUsage == null) {
+      if (memberUsage == null && !liveAbstractMembers.contains(oldMember)) {
         members.skipIndex(oldMember.memberIndex);
         continue;
       }
@@ -199,7 +200,7 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
       } else if (oldMember is ConstructorEntity) {
         final constructor = oldMember as IndexedConstructor;
         ParameterStructure parameterStructure =
-            annotations.hasNoElision(constructor)
+            annotations.hasNoElision(constructor) || memberUsage == null
                 ? constructor.parameterStructure
                 : memberUsage.invokedParameters!;
         if (constructor.isFactoryConstructor) {
@@ -231,7 +232,9 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
       } else {
         final function = oldMember as IndexedFunction;
         ParameterStructure parameterStructure =
-            annotations.hasNoElision(function)
+            annotations.hasNoElision(function) ||
+                    memberUsage == null ||
+                    function.isAbstract
                 ? function.parameterStructure
                 : memberUsage.invokedParameters!;
         newMember = JMethod(newLibrary, newClass, memberName,

pkg/compiler/lib/src/js_model/js_strategy.dart

@@ -184,6 +184,7 @@ class JsBackendStrategy implements interfaces.JsBackendStrategy {
         _compiler.environment,
         strategy.elementMap,
         closedWorld.liveMemberUsage,
+        closedWorld.liveAbstractInstanceMembers,
         closedWorld.annotationsData);
     ClosureDataBuilder closureDataBuilder = ClosureDataBuilder(
         _compiler.reporter, _elementMap, closedWorld.annotationsData);

pkg/compiler/lib/src/js_model/js_world.dart

@@ -88,6 +88,8 @@ class JClosedWorld implements World {
 
   final Set<MemberEntity> liveInstanceMembers;
 
+  final Set<MemberEntity> liveAbstractInstanceMembers;
+
   /// Members that are written either directly or through a setter selector.
   final Set<MemberEntity> assignedInstanceMembers;
 
@@ -125,6 +127,7 @@ class JClosedWorld implements World {
       this.implementedClasses,
       this.liveNativeClasses,
       this.liveInstanceMembers,
+      this.liveAbstractInstanceMembers,
       this.assignedInstanceMembers,
       this.processedMembers,
       this.extractTypeArgumentsInterfacesNewRti,
@@ -171,6 +174,8 @@ class JClosedWorld implements World {
     Set<ClassEntity> extractTypeArgumentsInterfacesNewRti =
         source.readClasses().toSet();
     Set<MemberEntity> liveInstanceMembers = source.readMembers().toSet();
+    Set<MemberEntity> liveAbstractInstanceMembers =
+        source.readMembers().toSet();
     Set<MemberEntity> assignedInstanceMembers = source.readMembers().toSet();
     Set<MemberEntity> processedMembers = source.readMembers().toSet();
     Map<ClassEntity, Set<ClassEntity>> mixinUses =
@@ -204,6 +209,7 @@ class JClosedWorld implements World {
         implementedClasses,
         liveNativeClasses,
         liveInstanceMembers,
+        liveAbstractInstanceMembers,
         assignedInstanceMembers,
         processedMembers,
         extractTypeArgumentsInterfacesNewRti,
@@ -232,6 +238,7 @@ class JClosedWorld implements World {
     sink.writeClasses(liveNativeClasses);
     sink.writeClasses(extractTypeArgumentsInterfacesNewRti);
     sink.writeMembers(liveInstanceMembers);
+    sink.writeMembers(liveAbstractInstanceMembers);
     sink.writeMembers(assignedInstanceMembers);
     sink.writeMembers(processedMembers);
     sink.writeClassMap(

pkg/compiler/lib/src/js_model/js_world_builder.dart

@@ -111,6 +111,8 @@ class JClosedWorldBuilder {
 
     Set<MemberEntity> liveInstanceMembers =
         map.toBackendMemberSet(closedWorld.liveInstanceMembers);
+    Set<MemberEntity> liveAbstractInstanceMembers =
+        map.toBackendMemberSet(closedWorld.liveAbstractInstanceMembers);
 
     Map<ClassEntity, Set<ClassEntity>> mixinUses =
         map.toBackendClassMap(closedWorld.mixinUses, map.toBackendClassSet);
@@ -226,6 +228,7 @@ class JClosedWorldBuilder {
         // represent the synthesized call methods for static and instance method
         // closurizations.
         liveInstanceMembers /*..addAll(callMethods)*/,
+        liveAbstractInstanceMembers,
         assignedInstanceMembers,
         processedMembers,
         extractTypeArgumentsInterfacesNewRti,

pkg/compiler/lib/src/kernel/env.dart

@@ -246,6 +246,7 @@ abstract class KClassEnv {
   JClassEnv convert(
       IrToElementMap kElementMap,
       Map<MemberEntity, MemberUsage> liveMemberUsage,
+      Set<MemberEntity> liveAbstractMembers,
       LibraryEntity Function(ir.Library library) getJLibrary);
 
   /// Returns `true` if [node] is a known member of this class.
@@ -435,6 +436,7 @@ class KClassEnvImpl implements KClassEnv {
   JClassEnv convert(
       IrToElementMap kElementMap,
       Map<MemberEntity, MemberUsage> liveMemberUsage,
+      Set<MemberEntity> liveAbstractMembers,
       LibraryEntity Function(ir.Library library) getJLibrary) {
     Map<String, ir.Member> constructorMap;
     Map<Name, ir.Member> memberMap;
@@ -445,7 +447,8 @@ class KClassEnvImpl implements KClassEnv {
       constructorMap = <String, ir.Member>{};
       _constructorMap!.forEach((String name, ir.Member node) {
         MemberEntity member = kElementMap.getMember(node);
-        if (liveMemberUsage.containsKey(member)) {
+        if (liveMemberUsage.containsKey(member) ||
+            liveAbstractMembers.contains(member)) {
           constructorMap[name] = node;
         }
       });
@@ -456,7 +459,8 @@ class KClassEnvImpl implements KClassEnv {
       memberMap = <Name, ir.Member>{};
       _memberMap!.forEach((Name name, ir.Member node) {
         MemberEntity member = kElementMap.getMember(node);
-        if (liveMemberUsage.containsKey(member)) {
+        if (liveMemberUsage.containsKey(member) ||
+            liveAbstractMembers.contains(member)) {
           memberMap[name] = node;
         }
       });
@@ -467,7 +471,8 @@ class KClassEnvImpl implements KClassEnv {
       members = <ir.Member>[];
       _members!.forEach((ir.Member node) {
         MemberEntity member = kElementMap.getMember(node);
-        if (liveMemberUsage.containsKey(member)) {
+        if (liveMemberUsage.containsKey(member) ||
+            liveAbstractMembers.contains(member)) {
           members.add(node);
         }
       });
@@ -682,7 +687,12 @@ class KFunctionDataImpl extends KMemberDataImpl
   @override
   FunctionData convert() {
     return FunctionDataImpl(
-        node, functionNode, RegularMemberDefinition(node), staticTypes!);
+        node,
+        functionNode,
+        RegularMemberDefinition(node),
+        // Abstract members without bodies will not have expressions so we use
+        // an empty cache.
+        staticTypes ?? const StaticTypeCache());
   }
 
   @override
@@ -757,7 +767,12 @@ class KFieldDataImpl extends KMemberDataImpl implements KFieldData {
 
   @override
   JFieldData convert() {
-    return JFieldDataImpl(node, RegularMemberDefinition(node), staticTypes!);
+    return JFieldDataImpl(
+        node,
+        RegularMemberDefinition(node),
+        // Late fields in abstract classes won't have initializers so we use an
+        // empty cache.
+        staticTypes ?? const StaticTypeCache());
   }
 }
 

pkg/compiler/lib/src/kernel/kernel_world.dart

@@ -40,6 +40,7 @@ class KClosedWorld implements BuiltWorld {
   // TODO(johnniwinther): Can this be derived from [ClassSet]s?
   final Set<ClassEntity> _implementedClasses;
   final Iterable<MemberEntity> liveInstanceMembers;
+  final Iterable<MemberEntity> liveAbstractInstanceMembers;
 
   /// Members that are written either directly or through a setter selector.
   final Iterable<MemberEntity> assignedInstanceMembers;
@@ -102,6 +103,7 @@ class KClosedWorld implements BuiltWorld {
       required Set<ClassEntity> implementedClasses,
       required this.liveNativeClasses,
       required this.liveInstanceMembers,
+      required this.liveAbstractInstanceMembers,
       required this.assignedInstanceMembers,
       required this.liveMemberUsage,
       required this.mixinUses,

pkg/compiler/lib/src/resolution/enqueuer.dart

@@ -122,6 +122,9 @@ class ResolutionEnqueuer extends Enqueuer {
     }
     if (useSet.contains(ClassUse.IMPLEMENTED)) {
       applyImpact(listener.registerImplementedClass(cls));
+      if (cls.isAbstract) {
+        worldBuilder.processAbstractClassMembers(cls, _applyMemberUse);
+      }
     }
   }
 

pkg/compiler/lib/src/universe/resolution_world_builder.dart

@@ -268,6 +268,7 @@ class ResolutionWorldBuilder extends WorldBuilder
   bool _closed = false;
   KClosedWorld? _closedWorldCache;
   final Set<MemberEntity> _liveInstanceMembers = {};
+  final Set<MemberEntity> _liveAbstractInstanceMembers = {};
 
   final Set<ConstantValue> _constantValues = {};
 
@@ -451,9 +452,10 @@ class ResolutionWorldBuilder extends WorldBuilder
         EnumSet<MemberUse> action(MemberUsage usage),
         bool shouldBeRemoved(MemberUsage usage)) {
       _processSet(memberMap, methodName, (MemberUsage usage) {
-        if (selector.appliesUnnamed(usage.entity) &&
-            _selectorConstraintsStrategy.appliedUnnamed(
-                dynamicUse, usage.entity, this)) {
+        if (usage.entity.isAbstract ||
+            selector.appliesUnnamed(usage.entity) &&
+                (_selectorConstraintsStrategy.appliedUnnamed(
+                    dynamicUse, usage.entity, this))) {
           memberUsed(usage.entity, action(usage));
           return shouldBeRemoved(usage);
         }
@@ -680,11 +682,23 @@ class ResolutionWorldBuilder extends WorldBuilder
       {bool checkEnqueuerConsistency = false}) {
     _elementEnvironment.forEachClassMember(cls,
         (ClassEntity cls, MemberEntity member) {
-      _processInstantiatedClassMember(cls, member, memberUsed,
+      _processMemberInUsedClass(cls, member, memberUsed,
           checkEnqueuerConsistency: checkEnqueuerConsistency);
     });
   }
 
+  @override
+  void processAbstractClassMembers(
+      ClassEntity cls, MemberUsedCallback memberUsed) {
+    _elementEnvironment.forEachLocalClassMember(cls, (MemberEntity member) {
+      if (member.isAbstract) {
+        // Check for potential usages of abstract members (i.e. of their
+        // overrides) and save them if they are used.
+        _processMemberInUsedClass(cls, member, memberUsed);
+      }
+    });
+  }
+
   /// Call [updateUsage] on all [MemberUsage]s in the set in [map] for
   /// [memberName]. If [updateUsage] returns `true` the usage is removed from
   /// the set.
@@ -785,7 +799,13 @@ class ResolutionWorldBuilder extends WorldBuilder
     return usage;
   }
 
-  void _processInstantiatedClassMember(
+  /// Determines whether [member] is potentially used and calls the [memberUsed]
+  /// callback on it if it is.
+  ///
+  /// [member] can be concrete or abstract and in either case potential usage
+  /// is determined by comparing the signature of [member] to the selector
+  /// structure (including arguments) at call sites.
+  void _processMemberInUsedClass(
       ClassEntity cls, MemberEntity member, MemberUsedCallback memberUsed,
       {bool checkEnqueuerConsistency = false}) {
     if (!member.isInstanceMember) return;
@@ -851,8 +871,12 @@ class ResolutionWorldBuilder extends WorldBuilder
 
   @override
   void registerUsedElement(MemberEntity element) {
-    if (element.isInstanceMember && !element.isAbstract) {
-      _liveInstanceMembers.add(element);
+    if (element.isInstanceMember) {
+      if (element.isAbstract) {
+        _liveAbstractInstanceMembers.add(element);
+      } else {
+        _liveInstanceMembers.add(element);
+      }
     }
   }
 
@@ -997,6 +1021,7 @@ class ResolutionWorldBuilder extends WorldBuilder
         implementedClasses: _implementedClasses,
         liveNativeClasses: _nativeResolutionEnqueuer.liveNativeClasses,
         liveInstanceMembers: _liveInstanceMembers,
+        liveAbstractInstanceMembers: _liveAbstractInstanceMembers,
         assignedInstanceMembers: computeAssignedInstanceMembers(),
         liveMemberUsage: liveMemberUsage,
         mixinUses: _classHierarchyBuilder.mixinUses,

pkg/compiler/lib/src/universe/resolution_world_builder_interfaces.dart

@@ -21,6 +21,9 @@ abstract class ResolutionWorldBuilder implements World {
   void processClassMembers(ClassEntity cls, MemberUsedCallback memberUsed,
       {bool checkEnqueuerConsistency = false});
 
+  void processAbstractClassMembers(
+      ClassEntity cls, MemberUsedCallback memberUsed);
+
   bool isInheritedIn(
       MemberEntity member, ClassEntity type, ClassRelation relation);