[dart2js] new-rti: lower field setters

Replace calls to field setters that don't need a check with HFieldSet.

Change-Id: I3408e87fc82686e66cf01d53a4ae10f94279041d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/112704
Commit-Queue: Stephen Adams <sra@google.com>
Reviewed-by: Mayank Patke <fishythefish@google.com>

Author: rakudrama

pkg/compiler/lib/src/inferrer/typemasks/masks.dart

@@ -305,6 +305,8 @@ class CommonMasks implements AbstractValueDomain {
     } else if (type is FunctionType) {
       return finish(
           TypeMask.subtype(commonElements.functionClass, _closedWorld), false);
+    } else if (type is DynamicType) {
+      return AbstractValueWithPrecision(dynamicType, true);
     } else {
       return finish(dynamicType, false);
     }

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

@@ -1335,41 +1335,64 @@ class SsaInstructionSimplifier extends HBaseVisitor
     // Use `node.inputs.last` in case the call follows the interceptor calling
     // convention, but is not a call on an interceptor.
     HInstruction value = node.inputs.last;
-    if (_closedWorld.annotationsData.getParameterCheckPolicy(field).isEmitted) {
-      if (_options.experimentNewRti) {
-        // TODO(sra): Implement inlining of setters with checks for new rti.
-        node.needsCheck = true;
-        return node;
-      }
-      DartType type = _closedWorld.elementEnvironment.getFieldType(field);
-      if (!type.treatAsRaw ||
-          type.isTypeVariable ||
-          type.unaliased.isFunctionType ||
-          type.unaliased.isFutureOr) {
-        // We cannot generate the correct type representation here, so don't
-        // inline this access.
-        // TODO(sra): If the input is such that we don't need a type check, we
-        // can skip the test an generate the HFieldSet.
-        node.needsCheck = true;
-        return node;
-      }
-      HInstruction other =
-          value.convertType(_closedWorld, type, HTypeConversion.TYPE_CHECK);
-      if (other != value) {
-        node.block.addBefore(node, other);
-        value = other;
+
+    HInstruction assignField() {
+      if (_closedWorld.fieldAnalysis.getFieldData(field).isElided) {
+        _log?.registerFieldSet(node);
+        return value;
+      } else {
+        HFieldSet result =
+            new HFieldSet(_abstractValueDomain, field, receiver, value)
+              ..sourceInformation = node.sourceInformation;
+        _log?.registerFieldSet(node, result);
+        return result;
       }
     }
-    if (_closedWorld.fieldAnalysis.getFieldData(field).isElided) {
-      _log?.registerFieldSet(node);
-      return value;
-    } else {
-      HFieldSet result =
-          new HFieldSet(_abstractValueDomain, field, receiver, value)
-            ..sourceInformation = node.sourceInformation;
-      _log?.registerFieldSet(node, result);
-      return result;
+
+    if (!_closedWorld.annotationsData
+        .getParameterCheckPolicy(field)
+        .isEmitted) {
+      return assignField();
     }
+
+    DartType fieldType = _closedWorld.elementEnvironment.getFieldType(field);
+
+    if (_options.experimentNewRti) {
+      AbstractValueWithPrecision checkedType =
+          _abstractValueDomain.createFromStaticType(fieldType);
+      if (checkedType.isPrecise &&
+          _abstractValueDomain
+              .isIn(value.instructionType, checkedType.abstractValue)
+              .isDefinitelyTrue) {
+        return assignField();
+      }
+      // TODO(sra): Implement inlining of setters with checks for new rti. The
+      // check and field assignmeny for the setter should inlined if this is the
+      // only call to the setter, or the current function already computes the
+      // type of the field.
+      node.needsCheck = true;
+      return node;
+    }
+
+    if (!fieldType.treatAsRaw ||
+        fieldType.isTypeVariable ||
+        fieldType.unaliased.isFunctionType ||
+        fieldType.unaliased.isFutureOr) {
+      // We cannot generate the correct type representation here, so don't
+      // inline this access.
+      // TODO(sra): If the input is such that we don't need a type check, we
+      // can skip the test an generate the HFieldSet.
+      node.needsCheck = true;
+      return node;
+    }
+    HInstruction other =
+        value.convertType(_closedWorld, fieldType, HTypeConversion.TYPE_CHECK);
+    if (other != value) {
+      node.block.addBefore(node, other);
+      value = other;
+    }
+
+    return assignField();
   }
 
   @override