[dart2js] Trust refined types from Dart type promotion

Using the promoted type reduces the need for primitive receiver and argument checks, and can result in better code.

The promoted type is 'used' by inserting pinned HTypeKnown instructions at the use site. The pinning can constrain code motion. Better inference in the optimizer (9505e95) relaxes most of these constraints.




Change-Id: Ic9c0ebe7fd95b60382e2f66c49f69440b8b881d1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/419484
Reviewed-by: Mayank Patke <[email protected]>
Commit-Queue: Stephen Adams <[email protected]>

Author: rakudrama

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

@@ -4720,13 +4720,38 @@ class KernelSsaGraphBuilder extends ir.VisitorDefault<void>
       return;
     }
 
-    Local local = _localsMap.getLocalVariable(node.variable);
-    stack.add(
-      localsHandler.readLocal(
-        local,
-        sourceInformation: _sourceInformationBuilder.buildGet(node),
-      ),
+    final local = _localsMap.getLocalVariable(node.variable);
+    final readLocal = localsHandler.readLocal(
+      local,
+      sourceInformation: _sourceInformationBuilder.buildGet(node),
     );
+
+    if (node.promotedType != null) {
+      // Use the prompted type by inserting a HTypeKnown refinement node.
+      //
+      // The front end does not tell us _why_ the type was promoted, so the
+      // HTypeKnown is pinned at the variable reference rather than at the
+      // control flow reponsible for the promotion. Pinning at the variable
+      // reference impairs code motion.
+      //
+      // Many of the promoted types are also refined by the optimizer (in
+      // SsaTypeConversionInserter, where controlling phis are handled). This
+      // causes a similar HTypeKnown to be inserted, but pinned at a location
+      // responsible the promotion. The optimizer-inserted HTypeKnown nodes
+      // dominate the nodes inserted here, allowing the nodes inserted here to
+      // be removed as redundant, sometimes lifting the code motion
+      // restriction. There is not an exact match between the front-end
+      // inference, so some of the promotions remain.
+      final trusted = _typeBuilder.trustPromotedType(
+        readLocal,
+        _getDartTypeIfValid(node.promotedType!),
+      );
+      if (trusted != readLocal) {
+        push(trusted);
+        return;
+      }
+    }
+    stack.add(readLocal);
   }
 
   void _handlePropertySet(

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

@@ -44,6 +44,12 @@ abstract class TypeBuilder {
     return mask;
   }
 
+  /// If needed, create a HTypeKnown to 'trust' the type of [original] when the
+  /// language type promotion has refined the type to [type].
+  HInstruction trustPromotedType(HInstruction original, DartType type) {
+    return _trustType(original, type);
+  }
+
   /// Create an instruction to simply trust the provided type.
   HInstruction _trustType(HInstruction original, DartType type) {
     bool hasLateSentinel =