Version 2.19.0-228.0.dev

Merge 76169b5 into dev

Author: Dart CI

pkg/compiler/lib/src/js_backend/impact_transformer.dart

@@ -152,8 +152,7 @@ class CodegenImpactTransformer {
     }
 
     for (Set<ClassEntity> classes in impact.specializedGetInterceptors) {
-      _oneShotInterceptorData.registerSpecializedGetInterceptor(
-          classes, _namer);
+      _oneShotInterceptorData.registerSpecializedGetInterceptor(classes);
     }
 
     if (impact.usesInterceptor) {

pkg/compiler/lib/src/js_backend/interceptor_data.dart

@@ -2,8 +2,6 @@
 // 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.
 
-// @dart = 2.10
-
 library js_backend.interceptor_data;
 
 import '../common/elements.dart'
@@ -16,8 +14,9 @@ import '../js/js.dart' as jsAst;
 import '../serialization/serialization.dart';
 import '../universe/class_set.dart';
 import '../universe/selector.dart';
-import '../world.dart' show JClosedWorld;
-import 'namer.dart' show ModularNamer, suffixForGetInterceptor;
+import '../world_interfaces.dart' show JClosedWorld;
+import 'namer_interfaces.dart' show ModularNamer;
+import 'namer_migrated.dart' show suffixForGetInterceptor;
 import 'native_data.dart';
 
 abstract class InterceptorData {
@@ -175,18 +174,13 @@ class InterceptorDataImpl implements InterceptorData {
 
   @override
   bool isInterceptedMixinSelector(
-      Selector selector, AbstractValue mask, JClosedWorld closedWorld) {
-    Set<MemberEntity> elements =
-        _interceptedMixinElements.putIfAbsent(selector.name, () {
-      Set<MemberEntity> elements = interceptedMembers[selector.name];
-      if (elements == null) return null;
-      return elements
-          .where((element) => classesMixedIntoInterceptedClasses
-              .contains(element.enclosingClass))
-          .toSet();
-    });
-
-    if (elements == null) return false;
+      Selector selector, AbstractValue? mask, JClosedWorld closedWorld) {
+    Set<MemberEntity> elements = _interceptedMixinElements[selector.name] ??=
+        (interceptedMembers[selector.name]
+                ?.where((element) => classesMixedIntoInterceptedClasses
+                    .contains(element.enclosingClass))
+                .toSet() ??
+            const {});
     if (elements.isEmpty) return false;
     return elements.any((element) {
       return selector.applies(element) &&
@@ -215,21 +209,21 @@ class InterceptorDataImpl implements InterceptorData {
   @override
   Set<ClassEntity> getInterceptedClassesOn(
       String name, JClosedWorld closedWorld) {
-    Set<MemberEntity> intercepted = interceptedMembers[name];
+    final intercepted = interceptedMembers[name];
     if (intercepted == null) return _noClasses;
     return _interceptedClassesCache.putIfAbsent(name, () {
       // Populate the cache by running through all the elements and
       // determine if the given selector applies to them.
       Set<ClassEntity> result = {};
       for (MemberEntity element in intercepted) {
-        ClassEntity classElement = element.enclosingClass;
+        final classElement = element.enclosingClass!;
         if (_isCompileTimeOnlyClass(classElement)) continue;
         if (_nativeData.isNativeOrExtendsNative(classElement) ||
             interceptedClasses.contains(classElement)) {
           result.add(classElement);
         }
         if (classesMixedIntoInterceptedClasses.contains(classElement)) {
-          Set<ClassEntity> nativeSubclasses =
+          final nativeSubclasses =
               nativeSubclassesOfMixin(classElement, closedWorld);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
@@ -238,16 +232,15 @@ class InterceptorDataImpl implements InterceptorData {
     });
   }
 
-  Set<ClassEntity> nativeSubclassesOfMixin(
+  Set<ClassEntity>? nativeSubclassesOfMixin(
       ClassEntity mixin, JClosedWorld closedWorld) {
     Iterable<ClassEntity> uses = closedWorld.mixinUsesOf(mixin);
-    Set<ClassEntity> result = null;
+    Set<ClassEntity>? result;
     for (ClassEntity use in uses) {
       closedWorld.classHierarchy.forEachStrictSubclassOf(use,
           (ClassEntity subclass) {
         if (_nativeData.isNativeOrExtendsNative(subclass)) {
-          if (result == null) result = {};
-          result.add(subclass);
+          (result ??= {}).add(subclass);
         }
         return IterationStep.CONTINUE;
       });
@@ -256,7 +249,7 @@ class InterceptorDataImpl implements InterceptorData {
   }
 
   @override
-  bool isInterceptedClass(ClassEntity element) {
+  bool isInterceptedClass(ClassEntity? element) {
     if (element == null) return false;
     if (_nativeData.isNativeOrExtendsNative(element)) return true;
     if (interceptedClasses.contains(element)) return true;
@@ -275,7 +268,7 @@ class InterceptorDataImpl implements InterceptorData {
 
     if (!closedWorld.dartTypes.treatAsRawType(type)) return false;
     if (type is FutureOrType) return false;
-    InterfaceType interfaceType = type;
+    final interfaceType = type as InterfaceType;
     ClassEntity classElement = interfaceType.element;
     if (isInterceptedClass(classElement)) return false;
     return closedWorld.classHierarchy.hasOnlySubclasses(classElement);
@@ -320,7 +313,7 @@ class InterceptorDataBuilderImpl implements InterceptorDataBuilder {
       if (member.name == Identifiers.call) return;
       // All methods on [Object] are shadowed by [Interceptor].
       if (cls == _commonElements.objectClass) return;
-      Set<MemberEntity> set = _interceptedElements[member.name] ??= {};
+      final set = _interceptedElements[member.name!] ??= {};
       set.add(member);
     });
 
@@ -337,7 +330,7 @@ class InterceptorDataBuilderImpl implements InterceptorDataBuilder {
           (ClassEntity cls, MemberEntity member) {
         // All methods on [Object] are shadowed by [Interceptor].
         if (cls == _commonElements.objectClass) return;
-        Set<MemberEntity> set = _interceptedElements[member.name] ??= {};
+        final set = _interceptedElements[member.name!] ??= {};
         set.add(member);
       });
     }
@@ -386,12 +379,11 @@ class OneShotInterceptorData {
     OneShotInterceptor interceptor =
         interceptors[key] ??= OneShotInterceptor(key, selector);
     interceptor.classes.addAll(classes);
-    registerSpecializedGetInterceptor(classes, namer);
+    registerSpecializedGetInterceptor(classes);
     return namer.nameForOneShotInterceptor(selector, classes);
   }
 
-  void registerSpecializedGetInterceptor(
-      Set<ClassEntity> classes, ModularNamer namer) {
+  void registerSpecializedGetInterceptor(Iterable<ClassEntity> classes) {
     if (classes.contains(_commonElements.jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.

pkg/compiler/lib/src/js_backend/namer.dart

@@ -35,6 +35,10 @@ import '../util/util.dart';
 import '../world.dart' show JClosedWorld;
 import 'deferred_holder_expression.dart';
 import 'native_data.dart';
+import 'namer_interfaces.dart' as interfaces;
+import 'namer_migrated.dart';
+
+export 'namer_migrated.dart' show suffixForGetInterceptor;
 
 part 'field_naming_mixin.dart';
 part 'frequency_namer.dart';
@@ -1554,38 +1558,6 @@ class _TypeConstantRepresentationVisitor extends DartTypeVisitor<String, Null> {
       'FutureOr<${_represent(type.typeArgument)}>';
 }
 
-/// Returns a unique suffix for an intercepted accesses to [classes]. This is
-/// used as the suffix for emitted interceptor methods and as the unique key
-/// used to distinguish equivalences of sets of intercepted classes.
-String suffixForGetInterceptor(CommonElements commonElements,
-    NativeData nativeData, Iterable<ClassEntity> classes) {
-  String abbreviate(ClassEntity cls) {
-    if (cls == commonElements.objectClass) return "o";
-    if (cls == commonElements.jsStringClass) return "s";
-    if (cls == commonElements.jsArrayClass) return "a";
-    if (cls == commonElements.jsNumNotIntClass) return "d";
-    if (cls == commonElements.jsIntClass) return "i";
-    if (cls == commonElements.jsNumberClass) return "n";
-    if (cls == commonElements.jsNullClass) return "u";
-    if (cls == commonElements.jsBoolClass) return "b";
-    if (cls == commonElements.jsInterceptorClass) return "I";
-    return cls.name;
-  }
-
-  List<String> names = classes
-      .where((cls) => !nativeData.isNativeOrExtendsNative(cls))
-      .map(abbreviate)
-      .toList();
-  // There is one dispatch mechanism for all native classes.
-  if (classes.any((cls) => nativeData.isNativeOrExtendsNative(cls))) {
-    names.add("x");
-  }
-  // Sort the names of the classes after abbreviating them to ensure
-  // the suffix is stable and predictable for the suggested names.
-  names.sort();
-  return names.join();
-}
-
 /// Generator of names for [ConstantValue] values.
 ///
 /// The names are stable under perturbations of the source.  The name is either
@@ -2133,7 +2105,7 @@ class MinifiedFixedNames extends FixedNames {
 }
 
 /// Namer interface that can be used in modular code generation.
-abstract class ModularNamer {
+abstract class ModularNamer implements interfaces.ModularNamer {
   FixedNames get fixedNames;
 
   /// Returns a variable use for accessing constants.
@@ -2241,6 +2213,7 @@ abstract class ModularNamer {
 
   /// Property name used for the one-shot interceptor method for the given
   /// [selector] and return-type specialization.
+  @override
   jsAst.Name nameForOneShotInterceptor(
       Selector selector, Set<ClassEntity> classes);
 

pkg/compiler/lib/src/js_backend/namer_interfaces.dart

@@ -0,0 +1,12 @@
+// Copyright (c) 2022, 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.
+
+import '../elements/entities.dart';
+import '../js/js.dart' as jsAst;
+import '../universe/selector.dart' show Selector;
+
+abstract class ModularNamer {
+  jsAst.Name nameForOneShotInterceptor(
+      Selector selector, Set<ClassEntity> classes);
+}

pkg/compiler/lib/src/js_backend/namer_migrated.dart

@@ -0,0 +1,39 @@
+// Copyright (c) 2022, 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.
+
+import '../common/elements.dart';
+import '../elements/entities.dart';
+import '../js_backend/native_data.dart';
+
+/// Returns a unique suffix for an intercepted accesses to [classes]. This is
+/// used as the suffix for emitted interceptor methods and as the unique key
+/// used to distinguish equivalences of sets of intercepted classes.
+String suffixForGetInterceptor(CommonElements commonElements,
+    NativeData nativeData, Iterable<ClassEntity> classes) {
+  String abbreviate(ClassEntity cls) {
+    if (cls == commonElements.objectClass) return "o";
+    if (cls == commonElements.jsStringClass) return "s";
+    if (cls == commonElements.jsArrayClass) return "a";
+    if (cls == commonElements.jsNumNotIntClass) return "d";
+    if (cls == commonElements.jsIntClass) return "i";
+    if (cls == commonElements.jsNumberClass) return "n";
+    if (cls == commonElements.jsNullClass) return "u";
+    if (cls == commonElements.jsBoolClass) return "b";
+    if (cls == commonElements.jsInterceptorClass) return "I";
+    return cls.name;
+  }
+
+  List<String> names = classes
+      .where((cls) => !nativeData.isNativeOrExtendsNative(cls))
+      .map(abbreviate)
+      .toList();
+  // There is one dispatch mechanism for all native classes.
+  if (classes.any((cls) => nativeData.isNativeOrExtendsNative(cls))) {
+    names.add("x");
+  }
+  // Sort the names of the classes after abbreviating them to ensure
+  // the suffix is stable and predictable for the suggested names.
+  names.sort();
+  return names.join();
+}

pkg/compiler/lib/src/world.dart

@@ -107,6 +107,7 @@ abstract class JClosedWorld implements interfaces.JClosedWorld {
   Iterable<ClassEntity> commonSupertypesOf(Iterable<ClassEntity> classes);
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
+  @override
   Iterable<ClassEntity> mixinUsesOf(ClassEntity cls);
 
   /// Returns `true` if [cls] is mixed into a live class.

pkg/compiler/lib/src/world_interfaces.dart

@@ -45,6 +45,8 @@ abstract class JClosedWorld implements World {
   bool fieldNeverChanges(MemberEntity element);
 
   Selector getSelector(ir.Expression node);
+
+  Iterable<ClassEntity> mixinUsesOf(ClassEntity cls);
 }
 
 // TODO(48820): Move back to `world.dart` when migrated.

tools/VERSION

@@ -27,5 +27,5 @@ CHANNEL dev
 MAJOR 2
 MINOR 19
 PATCH 0
-PRERELEASE 227
+PRERELEASE 228
 PRERELEASE_PATCH 0