[dart2js] Add @pragma('dart2js:disable-inlining') annotation

This annotation prevents inlining at call sites within the method that
is annotated.

The main expected use is to control inlining in unit tests.

Change-Id: Ib6652f0b4cb7a34c6bf829b1be5c09e241ffbde2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/248345
Commit-Queue: Stephen Adams <[email protected]>
Reviewed-by: Sigmund Cherem <[email protected]>

Author: rakudrama

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

@@ -22,6 +22,10 @@ class PragmaAnnotation {
   final bool forFieldsOnly;
   final bool internalOnly;
 
+  // TODO(sra): Review [forFunctionsOnly] and [forFieldsOnly]. Fields have
+  // implied getters and setters, so some annotations meant only for functions
+  // could reasonable be placed on a field to apply to the getter and setter.
+
   const PragmaAnnotation(this._index, this.name,
       {this.forFunctionsOnly = false,
       this.forFieldsOnly = false,
@@ -41,15 +45,20 @@ class PragmaAnnotation {
   static const PragmaAnnotation tryInline =
       PragmaAnnotation(1, 'tryInline', forFunctionsOnly: true);
 
+  /// Annotation on a member that tells the optimizing compiler to disable
+  /// inlining at call sites within the member.
+  static const PragmaAnnotation disableInlining =
+      PragmaAnnotation(2, 'disable-inlining');
+
   static const PragmaAnnotation disableFinal = PragmaAnnotation(
-      2, 'disableFinal',
+      3, 'disableFinal',
       forFunctionsOnly: true, internalOnly: true);
 
-  static const PragmaAnnotation noElision = PragmaAnnotation(3, 'noElision');
+  static const PragmaAnnotation noElision = PragmaAnnotation(4, 'noElision');
 
   /// Tells the optimizing compiler that the annotated method cannot throw.
   /// Requires @pragma('dart2js:noInline') to function correctly.
-  static const PragmaAnnotation noThrows = PragmaAnnotation(4, 'noThrows',
+  static const PragmaAnnotation noThrows = PragmaAnnotation(5, 'noThrows',
       forFunctionsOnly: true, internalOnly: true);
 
   /// Tells the optimizing compiler that the annotated method has no
@@ -58,56 +67,57 @@ class PragmaAnnotation {
   ///
   /// Requires @pragma('dart2js:noInline') to function correctly.
   static const PragmaAnnotation noSideEffects = PragmaAnnotation(
-      5, 'noSideEffects',
+      6, 'noSideEffects',
       forFunctionsOnly: true, internalOnly: true);
 
   /// Use this as metadata on method declarations to disable closed world
   /// assumptions on parameters, effectively assuming that the runtime arguments
   /// could be any value. Note that the constraints due to static types still
   /// apply.
   static const PragmaAnnotation assumeDynamic = PragmaAnnotation(
-      6, 'assumeDynamic',
+      7, 'assumeDynamic',
       forFunctionsOnly: true, internalOnly: true);
 
-  static const PragmaAnnotation asTrust = PragmaAnnotation(7, 'as:trust',
+  static const PragmaAnnotation asTrust = PragmaAnnotation(8, 'as:trust',
       forFunctionsOnly: false, internalOnly: false);
 
-  static const PragmaAnnotation asCheck = PragmaAnnotation(8, 'as:check',
+  static const PragmaAnnotation asCheck = PragmaAnnotation(9, 'as:check',
       forFunctionsOnly: false, internalOnly: false);
 
-  static const PragmaAnnotation typesTrust = PragmaAnnotation(9, 'types:trust',
+  static const PragmaAnnotation typesTrust = PragmaAnnotation(10, 'types:trust',
       forFunctionsOnly: false, internalOnly: false);
 
-  static const PragmaAnnotation typesCheck = PragmaAnnotation(10, 'types:check',
+  static const PragmaAnnotation typesCheck = PragmaAnnotation(11, 'types:check',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation parameterTrust = PragmaAnnotation(
-      11, 'parameter:trust',
+      12, 'parameter:trust',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation parameterCheck = PragmaAnnotation(
-      12, 'parameter:check',
+      13, 'parameter:check',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation downcastTrust = PragmaAnnotation(
-      13, 'downcast:trust',
+      14, 'downcast:trust',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation downcastCheck = PragmaAnnotation(
-      14, 'downcast:check',
+      15, 'downcast:check',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation indexBoundsTrust = PragmaAnnotation(
-      15, 'index-bounds:trust',
+      16, 'index-bounds:trust',
       forFunctionsOnly: false, internalOnly: false);
 
   static const PragmaAnnotation indexBoundsCheck = PragmaAnnotation(
-      16, 'index-bounds:check',
+      17, 'index-bounds:check',
       forFunctionsOnly: false, internalOnly: false);
 
   static const List<PragmaAnnotation> values = [
     noInline,
     tryInline,
+    disableInlining,
     disableFinal,
     noElision,
     noThrows,
@@ -273,6 +283,9 @@ abstract class AnnotationsData {
   /// annotation.
   bool hasTryInline(MemberEntity member);
 
+  /// Returns `true` if inlining is disabled at call sites inside [member].
+  bool hasDisableInlining(MemberEntity member);
+
   /// Returns `true` if [member] has a `@pragma('dart2js:disableFinal')`
   /// annotation.
   bool hasDisableFinal(MemberEntity member);
@@ -343,6 +356,7 @@ class AnnotationsDataImpl implements AnnotationsData {
   final CheckPolicy _defaultConditionCheckPolicy;
   final CheckPolicy _defaultExplicitCastCheckPolicy;
   final CheckPolicy _defaultIndexBoundsCheckPolicy;
+  final bool _defaultDisableInlining;
   final Map<MemberEntity, EnumSet<PragmaAnnotation>> pragmaAnnotations;
 
   AnnotationsDataImpl(CompilerOptions options, this.pragmaAnnotations)
@@ -353,7 +367,8 @@ class AnnotationsDataImpl implements AnnotationsData {
         this._defaultExplicitCastCheckPolicy =
             options.defaultExplicitCastCheckPolicy,
         this._defaultIndexBoundsCheckPolicy =
-            options.defaultIndexBoundsCheckPolicy;
+            options.defaultIndexBoundsCheckPolicy,
+        this._defaultDisableInlining = options.disableInlining;
 
   factory AnnotationsDataImpl.readFromDataSource(
       CompilerOptions options, DataSourceReader source) {
@@ -392,6 +407,11 @@ class AnnotationsDataImpl implements AnnotationsData {
   bool hasTryInline(MemberEntity member) =>
       _hasPragma(member, PragmaAnnotation.tryInline);
 
+  @override
+  bool hasDisableInlining(MemberEntity member) =>
+      _hasPragma(member, PragmaAnnotation.disableInlining) ||
+      _defaultDisableInlining;
+
   @override
   bool hasDisableFinal(MemberEntity member) =>
       _hasPragma(member, PragmaAnnotation.disableFinal);

pkg/compiler/lib/src/ssa/builder.dart

@@ -5830,6 +5830,13 @@ class KernelSsaGraphBuilder extends ir.Visitor<void> with ir.VisitorVoidMixin {
       return false;
     }
 
+    // Check if inlining is disabled for the current element (includes globally)
+    // before making decsions on the basis of the callee so that cached callee
+    // decisions are not a function of the call site's method.
+    if (closedWorld.annotationsData.hasDisableInlining(_currentFrame.member)) {
+      return false;
+    }
+
     bool insideLoop = loopDepth > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
@@ -5840,8 +5847,6 @@ class KernelSsaGraphBuilder extends ir.Visitor<void> with ir.VisitorVoidMixin {
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
-      if (options.disableInlining) return false;
-
       assert(
           selector != null ||
               function.isStatic ||

pkg/compiler/test/annotations/data/basic.dart

@@ -11,6 +11,8 @@ main() {
   noThrows();
   noSideEffects();
   assumeDynamic();
+  disableInlining();
+  several();
 }
 
 /*member: noInline:noInline*/
@@ -38,3 +40,15 @@ noSideEffects() {}
 /*member: assumeDynamic:assumeDynamic*/
 @pragma('dart2js:assumeDynamic')
 assumeDynamic() {}
+
+/*member: disableInlining:disable-inlining*/
+@pragma('dart2js:disable-inlining')
+disableInlining() {}
+
+/*member: several:assumeDynamic,disable-inlining,noInline,noSideEffects,noThrows*/
+@pragma('dart2js:disable-inlining')
+@pragma('dart2js:noThrows')
+@pragma('dart2js:noSideEffects')
+@pragma('dart2js:assumeDynamic')
+@pragma('dart2js:noInline')
+several() {}

pkg/compiler/test/codegen/data/inlining_annotations.dart

@@ -0,0 +1,76 @@
+// 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.
+
+/*member: foo1:ignore*/
+@pragma('dart2js:tryInline')
+int foo1() => bar1();
+
+/*member: foo2:ignore*/
+@pragma('dart2js:tryInline')
+@pragma('dart2js:disable-inlining')
+int foo2() => bar2();
+
+/*member: foo3:ignore*/
+@pragma('dart2js:noInline')
+int foo3() => bar3();
+
+/*member: bar1:ignore*/
+int bar1() => 1;
+
+/*member: bar2:ignore*/
+int bar2() => 2;
+
+/*member: bar3:ignore*/
+int bar3() => 3;
+
+// All calls to `barN` are inlined because this improves size and performance.
+/*member: test1:function() {
+  A.use(1, 2, 3);
+}*/
+@pragma('dart2js:noInline')
+void test1() {
+  use(bar1(), bar2(), bar3());
+}
+
+// No calls to `barN` are inlined due to `disable-inlining`.
+/*member: test2:function() {
+  A.use(A.bar1(), A.bar2(), A.bar3());
+}*/
+@pragma('dart2js:noInline')
+@pragma('dart2js:disable-inlining')
+void test2() {
+  use(bar1(), bar2(), bar3());
+}
+
+// `foo` and `bar1` are inlined. `foo2` is inlined, but the contained call to
+// `bar2` is not inlined due to `disable-inlining` on `foo2`.
+/*member: test3:function() {
+  A.use(1, A.bar2(), A.foo3());
+}*/
+@pragma('dart2js:noInline')
+void test3() {
+  use(foo1(), foo2(), foo3());
+}
+
+// None of the `fooN` calls are inlined due to `disable-inlining`.
+/*member: test4:function() {
+  A.use(A.foo1(), A.foo2(), A.foo3());
+}*/
+@pragma('dart2js:noInline')
+@pragma('dart2js:disable-inlining')
+void test4() {
+  use(foo1(), foo2(), foo3());
+}
+
+/*member: use:ignore*/
+@pragma('dart2js:noInline')
+void use(int a, int b, int c) {}
+
+/*member: main:ignore*/
+main() {
+  test1();
+  test2();
+  test3();
+  test4();
+}