[dart2js] Special case null is T.

Change-Id: Iec5212db2d4493797257753f9eaa63799d047253
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138574
Reviewed-by: Sigmund Cherem <[email protected]>
Commit-Queue: Mayank Patke <[email protected]>

Author: fishythefish

pkg/compiler/lib/src/common_elements.dart

@@ -513,6 +513,9 @@ abstract class CommonElements {
   FunctionEntity get generalAsCheckImplementation;
   FunctionEntity get generalTypeCheckImplementation;
 
+  FunctionEntity get specializedIsObject;
+  FunctionEntity get specializedAsObject;
+  FunctionEntity get specializedCheckObject;
   FunctionEntity get specializedIsTop;
   FunctionEntity get specializedAsTop;
   FunctionEntity get specializedIsBool;
@@ -1976,6 +1979,21 @@ class CommonElementsImpl
       _generalTypeCheckImplementation ??=
           _findRtiFunction('_generalTypeCheckImplementation');
 
+  FunctionEntity _specializedIsObject;
+  @override
+  FunctionEntity get specializedIsObject =>
+      _specializedIsObject ??= _findRtiFunction('_isObject');
+
+  FunctionEntity _specializedAsObject;
+  @override
+  FunctionEntity get specializedAsObject =>
+      _specializedAsObject ??= _findRtiFunction('_asObject');
+
+  FunctionEntity _specializedCheckObject;
+  @override
+  FunctionEntity get specializedCheckObject =>
+      _specializedCheckObject ??= _findRtiFunction('_checkObject');
+
   @override
   FunctionEntity get specializedIsTop => _findRtiFunction('_isTop');
 

pkg/compiler/lib/src/inferrer/type_graph_nodes.dart

@@ -2248,42 +2248,36 @@ abstract class TypeInformationVisitor<T> {
   T visitYieldTypeInformation(YieldTypeInformation info);
 }
 
-AbstractValue _intersection(AbstractValue type, AbstractValue otherType,
-    AbstractValueDomain abstractValueDomain, bool isNullable) {
-  if (isNullable) {
-    otherType = abstractValueDomain.includeNull(otherType);
-  }
-  return type == null
-      ? otherType
-      : abstractValueDomain.intersection(type, otherType);
-}
-
 AbstractValue _narrowType(
     JClosedWorld closedWorld, AbstractValue type, DartType annotation,
     {bool isNullable: true}) {
-  annotation = annotation.withoutNullability;
   AbstractValueDomain abstractValueDomain = closedWorld.abstractValueDomain;
+
+  AbstractValue _intersectionWith(AbstractValue otherType) {
+    if (isNullable) {
+      otherType = abstractValueDomain.includeNull(otherType);
+    }
+    return type == null
+        ? otherType
+        : abstractValueDomain.intersection(type, otherType);
+  }
+
   // TODO(joshualitt): FutureOrType, TypeVariableType, and FunctionTypeVariable
   // can be narrowed.
+  // TODO(fishythefish): Use nullability.
+  annotation = annotation.withoutNullability;
   if (closedWorld.dartTypes.isTopType(annotation) ||
-      annotation is VoidType ||
-      annotation is NeverType ||
       annotation is FutureOrType ||
       annotation is TypeVariableType ||
       annotation is FunctionTypeVariable) {
     return type;
+  } else if (annotation is NeverType) {
+    return _intersectionWith(abstractValueDomain.emptyType);
   } else if (annotation is InterfaceType) {
-    if (annotation.element == closedWorld.commonElements.objectClass) {
-      return type;
-    }
-    return _intersection(
-        type,
-        abstractValueDomain.createNonNullSubtype(annotation.element),
-        abstractValueDomain,
-        isNullable);
+    return _intersectionWith(
+        abstractValueDomain.createNonNullSubtype(annotation.element));
   } else if (annotation is FunctionType) {
-    return _intersection(type, closedWorld.abstractValueDomain.functionType,
-        abstractValueDomain, isNullable);
+    return _intersectionWith(abstractValueDomain.functionType);
   } else {
     throw 'Unexpected annotation type $annotation';
   }

pkg/compiler/lib/src/inferrer/type_system.dart

@@ -317,43 +317,42 @@ class TypeSystem {
   /// type.
   TypeInformation narrowType(TypeInformation type, DartType annotation,
       {bool isNullable: true}) {
+    TypeInformation _narrowTo(AbstractValue otherType) {
+      if (_abstractValueDomain.isExact(type.type).isDefinitelyTrue) return type;
+      if (isNullable) {
+        otherType = _abstractValueDomain.includeNull(otherType);
+      }
+      TypeInformation newType =
+          new NarrowTypeInformation(_abstractValueDomain, type, otherType);
+      allocatedTypes.add(newType);
+      return newType;
+    }
+
+    // TODO(fishythefish): Use nullability.
     annotation = annotation.withoutNullability;
-    AbstractValue otherType;
     if (annotation is VoidType) return type;
     if (_closedWorld.dartTypes.isTopType(annotation)) {
       if (isNullable) return type;
       // If the input is already narrowed to be not-null, there is no value
       // in adding another narrowing node.
       if (_isNonNullNarrow(type)) return type;
-      otherType = _abstractValueDomain.excludeNull(dynamicType.type);
+      return _narrowTo(_abstractValueDomain.excludeNull(dynamicType.type));
+    } else if (annotation is NeverType) {
+      return _narrowTo(_abstractValueDomain.emptyType);
     } else if (annotation is InterfaceType) {
-      InterfaceType interface = annotation;
-      if (interface.element == _closedWorld.commonElements.objectClass) {
-        if (isNullable) return type;
-        if (_isNonNullNarrow(type)) return type;
-        otherType = _abstractValueDomain.excludeNull(dynamicType.type);
-      } else {
-        otherType =
-            _abstractValueDomain.createNonNullSubtype(interface.element);
-      }
+      return _narrowTo(
+          _abstractValueDomain.createNonNullSubtype(annotation.element));
     } else if (annotation is FunctionType) {
-      otherType = functionType.type;
+      return _narrowTo(functionType.type);
     } else if (annotation is FutureOrType) {
       // TODO(johnniwinther): Support narrowing of FutureOr.
       return type;
-    } else {
-      assert(annotation is TypeVariableType);
+    } else if (annotation is TypeVariableType) {
       // TODO(ngeoffray): Narrow to bound.
       return type;
+    } else {
+      throw 'Unexpected annotation type $annotation';
     }
-    if (isNullable) {
-      otherType = _abstractValueDomain.includeNull(otherType);
-    }
-    if (_abstractValueDomain.isExact(type.type).isDefinitelyTrue) return type;
-    TypeInformation newType =
-        new NarrowTypeInformation(_abstractValueDomain, type, otherType);
-    allocatedTypes.add(newType);
-    return newType;
   }
 
   ParameterTypeInformation getInferredTypeOfParameter(Local parameter) {

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

@@ -832,6 +832,9 @@ class BackendImpacts {
           _commonElements.specializedIsTop,
           _commonElements.specializedAsTop,
           // no specializedCheckTop
+          _commonElements.specializedIsObject,
+          _commonElements.specializedAsObject,
+          _commonElements.specializedCheckObject,
         ], globalClasses: [
           _commonElements.closureClass, // instanceOrFunctionType uses this.
         ])

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

@@ -2599,16 +2599,6 @@ abstract class ModularNamer {
         return runtimeTypeName(_commonElements.jsJavaScriptFunctionClass);
       case JsGetName.FUTURE_CLASS_TYPE_NAME:
         return runtimeTypeName(_commonElements.futureClass);
-      case JsGetName.BOOL_RECIPE:
-        return runtimeTypeName(_commonElements.boolClass);
-      case JsGetName.DOUBLE_RECIPE:
-        return runtimeTypeName(_commonElements.doubleClass);
-      case JsGetName.INT_RECIPE:
-        return runtimeTypeName(_commonElements.intClass);
-      case JsGetName.NUM_RECIPE:
-        return runtimeTypeName(_commonElements.numClass);
-      case JsGetName.STRING_RECIPE:
-        return runtimeTypeName(_commonElements.stringClass);
       case JsGetName.RTI_FIELD_IS:
         return instanceFieldPropertyName(_commonElements.rtiIsField);
       default:

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

@@ -4543,8 +4543,9 @@ class HIsTest extends HInstruction {
   HInstruction get typeInput => inputs[0];
   HInstruction get checkedInput => inputs[1];
 
-  AbstractBool evaluate(JClosedWorld closedWorld) =>
-      _isTestResult(checkedInput, dartType, checkedAbstractValue, closedWorld);
+  AbstractBool evaluate(JClosedWorld closedWorld, bool useNullSafety) =>
+      _isTestResult(checkedInput, dartType, checkedAbstractValue, closedWorld,
+          useNullSafety);
 
   @override
   accept(HVisitor visitor) => visitor.visitIsTest(this);
@@ -4577,8 +4578,9 @@ class HIsTestSimple extends HInstruction {
 
   HInstruction get checkedInput => inputs[0];
 
-  AbstractBool evaluate(JClosedWorld closedWorld) =>
-      _isTestResult(checkedInput, dartType, checkedAbstractValue, closedWorld);
+  AbstractBool evaluate(JClosedWorld closedWorld, bool useNullSafety) =>
+      _isTestResult(checkedInput, dartType, checkedAbstractValue, closedWorld,
+          useNullSafety);
 
   @override
   accept(HVisitor visitor) => visitor.visitIsTestSimple(this);
@@ -4596,11 +4598,36 @@ class HIsTestSimple extends HInstruction {
   String toString() => 'HIsTestSimple()';
 }
 
-AbstractBool _isTestResult(HInstruction expression, DartType dartType,
-    AbstractValueWithPrecision checkedAbstractValue, JClosedWorld closedWorld) {
+AbstractBool _isTestResult(
+    HInstruction expression,
+    DartType dartType,
+    AbstractValueWithPrecision checkedAbstractValue,
+    JClosedWorld closedWorld,
+    bool useNullSafety) {
   AbstractValueDomain abstractValueDomain = closedWorld.abstractValueDomain;
   AbstractValue subsetType = expression.instructionType;
   AbstractValue supersetType = checkedAbstractValue.abstractValue;
+
+  if (useNullSafety &&
+      expression.isNull(abstractValueDomain).isDefinitelyTrue) {
+    if (closedWorld.dartTypes.isTopType(dartType) ||
+        dartType is NullableType ||
+        dartType.isNull) {
+      return AbstractBool.True;
+    }
+    if (dartType is TypeVariableType || dartType is FunctionTypeVariable) {
+      return AbstractBool.Maybe;
+    }
+    if (dartType is LegacyType) {
+      DartType baseType = dartType.baseType;
+      if (baseType is NeverType) return AbstractBool.True;
+      if (baseType is TypeVariableType || baseType is FunctionTypeVariable) {
+        return AbstractBool.Maybe;
+      }
+    }
+    return AbstractBool.False;
+  }
+
   if (checkedAbstractValue.isPrecise &&
       abstractValueDomain.isIn(subsetType, supersetType).isDefinitelyTrue) {
     return AbstractBool.True;

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

@@ -2123,6 +2123,9 @@ class SsaInstructionSimplifier extends HBaseVisitor
 
   @override
   HInstruction visitAsCheck(HAsCheck node) {
+    // TODO(fishythefish): Correctly constant fold `null as T` (also in
+    // [visitAsCheckSimple]) when running with strong NNBD. We might get this
+    // for free if nullability is precisely propagated to the typemasks.
     if (node.isRedundant(_closedWorld)) return node.checkedInput;
 
     // See if this check can be lowered to a simple one.
@@ -2153,7 +2156,7 @@ class SsaInstructionSimplifier extends HBaseVisitor
 
   @override
   HInstruction visitIsTest(HIsTest node) {
-    AbstractBool result = node.evaluate(_closedWorld);
+    AbstractBool result = node.evaluate(_closedWorld, _options.useNullSafety);
     if (result.isDefinitelyFalse) {
       return _graph.addConstantBool(false, _closedWorld);
     }
@@ -2199,7 +2202,7 @@ class SsaInstructionSimplifier extends HBaseVisitor
 
   @override
   HInstruction visitIsTestSimple(HIsTestSimple node) {
-    AbstractBool result = node.evaluate(_closedWorld);
+    AbstractBool result = node.evaluate(_closedWorld, _options.useNullSafety);
     if (result.isDefinitelyFalse) {
       return _graph.addConstantBool(false, _closedWorld);
     }