[vm/compiler] Do not initialize delayed_type_arguments_ for non-generic closures

This field is only used to implement partial instantiation of generic
closures - so it is irrelevant in non-generic ones.

Keeping it null instead of empty_type_arguments allows to completely
elide a store (which saves around 2 instructions per closure allocation)

Change-Id: I1039993a1cfd1bc4b476214712d90b2c443e7cc6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/121983
Commit-Queue: Vyacheslav Egorov <vegorov@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>

Author: mraleph

runtime/vm/compiler/backend/il_test.cc

@@ -157,24 +157,22 @@ ISOLATE_UNIT_TEST_CASE(IRTest_InitializingStores) {
                             /*expected_stores=*/{"f"});
   RunInitializingStoresTest(root_library, "f2", CompilerPass::kJIT,
                             /*expected_stores=*/{"g"});
-  RunInitializingStoresTest(
-      root_library, "f3", CompilerPass::kJIT,
-      /*expected_stores=*/
-      {"Closure.delayed_type_arguments", "Closure.function"});
+  RunInitializingStoresTest(root_library, "f3", CompilerPass::kJIT,
+                            /*expected_stores=*/
+                            {"Closure.function"});
 
   // Note that in JIT mode we lower context allocation in a way that hinders
   // removal of initializing moves so there would be some redundant stores of
   // null left in the graph. In AOT mode we don't apply this optimization
   // which enables us to remove more stores.
-  RunInitializingStoresTest(
-      root_library, "f4", CompilerPass::kJIT, /*expected_stores=*/
-      {"value", "Context.parent", "Context.parent", "value",
-       "Closure.function_type_arguments", "Closure.delayed_type_arguments",
-       "Closure.function", "Closure.context"});
+  RunInitializingStoresTest(root_library, "f4",
+                            CompilerPass::kJIT, /*expected_stores=*/
+                            {"value", "Context.parent", "Context.parent",
+                             "value", "Closure.function_type_arguments",
+                             "Closure.function", "Closure.context"});
   RunInitializingStoresTest(root_library, "f4",
                             CompilerPass::kAOT, /*expected_stores=*/
                             {"value", "Closure.function_type_arguments",
-                             "Closure.delayed_type_arguments",
                              "Closure.function", "Closure.context"});
 }
 

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -5108,11 +5108,15 @@ Fragment StreamingFlowGraphBuilder::BuildFunctionNode(
       TokenPosition::kNoSource, Slot::Closure_function_type_arguments(),
       StoreInstanceFieldInstr::Kind::kInitializing);
 
-  instructions += LoadLocal(closure);
-  instructions += Constant(Object::empty_type_arguments());
-  instructions += flow_graph_builder_->StoreInstanceField(
-      TokenPosition::kNoSource, Slot::Closure_delayed_type_arguments(),
-      StoreInstanceFieldInstr::Kind::kInitializing);
+  if (function.IsGeneric()) {
+    // Only generic functions need to have properly initialized
+    // delayed_type_arguments.
+    instructions += LoadLocal(closure);
+    instructions += Constant(Object::empty_type_arguments());
+    instructions += flow_graph_builder_->StoreInstanceField(
+        TokenPosition::kNoSource, Slot::Closure_delayed_type_arguments(),
+        StoreInstanceFieldInstr::Kind::kInitializing);
+  }
 
   // Store the function and the context in the closure.
   instructions += LoadLocal(closure);

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -1398,11 +1398,15 @@ Fragment FlowGraphBuilder::BuildImplicitClosureCreation(
       StoreInstanceField(TokenPosition::kNoSource, Slot::Closure_context(),
                          StoreInstanceFieldInstr::Kind::kInitializing);
 
-  fragment += LoadLocal(closure);
-  fragment += Constant(Object::empty_type_arguments());
-  fragment += StoreInstanceField(TokenPosition::kNoSource,
-                                 Slot::Closure_delayed_type_arguments(),
-                                 StoreInstanceFieldInstr::Kind::kInitializing);
+  if (target.IsGeneric()) {
+    // Only generic functions need to have properly initialized
+    // delayed_type_arguments.
+    fragment += LoadLocal(closure);
+    fragment += Constant(Object::empty_type_arguments());
+    fragment += StoreInstanceField(
+        TokenPosition::kNoSource, Slot::Closure_delayed_type_arguments(),
+        StoreInstanceFieldInstr::Kind::kInitializing);
+  }
 
   // The context is on top of the operand stack.  Store `this`.  The context
   // doesn't need a parent pointer because it doesn't close over anything

runtime/vm/object.cc

@@ -21696,7 +21696,9 @@ RawClosure* Closure::New(const TypeArguments& instantiator_type_arguments,
                          const Context& context,
                          Heap::Space space) {
   return Closure::New(instantiator_type_arguments, function_type_arguments,
-                      Object::empty_type_arguments(), function, context, space);
+                      function.IsGeneric() ? Object::empty_type_arguments()
+                                           : Object::null_type_arguments(),
+                      function, context, space);
 }
 
 RawClosure* Closure::New(const TypeArguments& instantiator_type_arguments,