[ddc] let compiler generate instanceof and == of types directly.

Change-Id: I87cb00cc4592125001d50505e9023c2ab45d95c4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138722
Commit-Queue: Sigmund Cherem <[email protected]>
Reviewed-by: Nicholas Shahan <[email protected]>
Reviewed-by: Mark Zhou <[email protected]>

Author: sigmundch

pkg/dev_compiler/lib/src/kernel/compiler.dart

@@ -4755,21 +4755,35 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     if (target.isFactory) return _emitFactoryInvocation(node);
 
     // Optimize some internal SDK calls.
-    if (isSdkInternalRuntime(target.enclosingLibrary) &&
-        node.arguments.positional.length == 1) {
-      var name = target.name.name;
-      var firstArg = node.arguments.positional[0];
-      if (name == 'getGenericClass' && firstArg is TypeLiteral) {
-        var type = firstArg.type;
-        if (type is InterfaceType) {
-          return _emitTopLevelNameNoInterop(type.classNode, suffix: '\$');
+    if (isSdkInternalRuntime(target.enclosingLibrary)) {
+      if (node.arguments.positional.length == 1) {
+        var name = target.name.name;
+        var firstArg = node.arguments.positional[0];
+        if (name == 'getGenericClass' && firstArg is TypeLiteral) {
+          var type = firstArg.type;
+          if (type is InterfaceType) {
+            return _emitTopLevelNameNoInterop(type.classNode, suffix: '\$');
+          }
+        }
+        if (name == 'unwrapType' && firstArg is TypeLiteral) {
+          return _emitType(firstArg.type);
+        }
+        if (name == 'extensionSymbol' && firstArg is StringLiteral) {
+          return getExtensionSymbolInternal(firstArg.value);
+        }
+      } else if (node.arguments.positional.length == 2) {
+        var name = target.name.name;
+        var firstArg = node.arguments.positional[0];
+        var secondArg = node.arguments.positional[1];
+        if (name == '_jsInstanceOf' && secondArg is TypeLiteral) {
+          return js.call('# instanceof #',
+              [_visitExpression(firstArg), _emitType(secondArg.type)]);
+        }
+
+        if (name == '_equalType' && secondArg is TypeLiteral) {
+          return js.call('# === #',
+              [_visitExpression(firstArg), _emitType(secondArg.type)]);
         }
-      }
-      if (name == 'unwrapType' && firstArg is TypeLiteral) {
-        return _emitType(firstArg.type);
-      }
-      if (name == 'extensionSymbol' && firstArg is StringLiteral) {
-        return getExtensionSymbolInternal(firstArg.value);
       }
     }
     if (target == _coreTypes.identicalProcedure) {

sdk_nnbd/lib/_internal/js_dev_runtime/private/ddc_runtime/classes.dart

@@ -142,17 +142,17 @@ normalizeFutureOr(typeConstructor, setBaseClass) {
 
     // FutureOr<dynamic|void|Object?|Object*> --> dynamic|void|Object?|Object*
     if (_isTop(typeArg) ||
-        (_isLegacy(typeArg) &&
+        (_jsInstanceOf(typeArg, LegacyType) &&
             JS<bool>('!', '#.type === #', typeArg, Object))) {
       return typeArg;
     }
 
     // FutureOr<Never> --> Future<Never>
-    if (typeArg == never_) {
+    if (_equalType(typeArg, Never)) {
       return JS('!', '#(#)', getGenericClass(Future), typeArg);
     }
     // FutureOr<Null> --> Future<Null>?
-    if (typeArg == unwrapType(Null)) {
+    if (_equalType(typeArg, Null)) {
       return nullable(JS('!', '#(#)', getGenericClass(Future), typeArg));
     }
     // Otherwise, create the FutureOr<T> type as a normal generic type.
@@ -286,7 +286,7 @@ bool isJsInterop(obj) {
   // Note that it is still possible to call typed JS interop methods on
   // extension types but the calls must be statically typed.
   if (JS('!', '#[#] != null', obj, _extensionType)) return false;
-  return JS('!', '!($obj instanceof $Object)');
+  return !_jsInstanceOf(obj, Object);
 }
 
 /// Get the type of a method from a type using the stored signature

sdk_nnbd/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart

@@ -301,7 +301,7 @@ _checkAndCall(f, ftype, obj, typeArgs, args, named, displayName) =>
   }
 
   // Apply type arguments
-  if ($ftype instanceof $GenericFunctionType) {
+  if (${_jsInstanceOf(ftype, GenericFunctionType)}) {
     let formalCount = $ftype.formalCount;
 
     if ($typeArgs == null) {
@@ -405,17 +405,27 @@ dindex(obj, index) => callMethod(obj, '_get', null, [index], null, '[]');
 dsetindex(obj, index, value) =>
     callMethod(obj, '_set', null, [index, value], null, '[]=');
 
+/// General implementation of the Dart `is` operator.
+///
+/// Some basic cases are handled directly by the `.is` methods that are attached
+/// directly on types, but any query that requires checking subtyping relations
+/// is handled here.
 @notNull
 @JSExportName('is')
 bool instanceOf(obj, type) {
   if (obj == null) {
-    return identical(type, unwrapType(Null)) ||
+    return _equalType(type, Null) ||
         _isTop(type) ||
-        _isNullable(type);
+        _jsInstanceOf(type, NullableType);
   }
   return isSubtypeOf(getReifiedType(obj), type);
 }
 
+/// General implementation of the Dart `as` operator.
+///
+/// Some basic cases are handled directly by the `.as` methods that are attached
+/// directly on types, but any query that requires checking subtyping relations
+/// is handled here.
 @JSExportName('as')
 cast(obj, type, @notNull bool isImplicit) {
   // We hoist the common case where null is checked against another type here

sdk_nnbd/lib/_internal/js_dev_runtime/private/ddc_runtime/rtti.dart

@@ -88,7 +88,7 @@ getReifiedType(obj) {
   switch (JS<String>('!', 'typeof #', obj)) {
     case "object":
       if (obj == null) return JS('', '#', Null);
-      if (JS('!', '# instanceof #', obj, Object)) {
+      if (_jsInstanceOf(obj, Object)) {
         return JS('', '#.constructor', obj);
       }
       var result = JS('', '#[#]', obj, _extensionType);