#3180. Add isA tests. Part 2. (#3271)

Add `isA` tests. Part 2.

Author: sgrekhov

LibTest/js_interop/JSAnyUtilityExtension/isA_A03_t04.dart

@@ -0,0 +1,43 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// If T is a non-primitive JS type like [JSArray] or an interop extension type
+/// on one, this uses an instanceof check using the name or the `@JS` rename of
+/// the given type like `instanceOfString('Array')`. Note that if you rename the
+/// library using the `@JS` annotation, this uses the rename in the instanceof
+/// check like `instanceOfString('library1.JSClass')`.
+///
+/// @description Checks that `isA<JSArray>` returns `true` for an extension type
+/// on `JSArray`. Test renaming to `Array`.
+/// @author [email protected]
+
+import 'dart:js_interop';
+import 'dart:js_interop_unsafe';
+import '../../../Utils/expect.dart';
+import '../js_utils.dart';
+
+@JS("Array")
+extension type MyArray(JSArray ar) implements JSArray {}
+
+main() {
+  MyArray ma1 = MyArray(JSArray());
+  globalContext["ma1"] = ma1;
+  Expect.isTrue(globalContext["ma1"].isA<JSArray>());
+  Expect.isFalse(globalContext["ma1"].isA<JSNumber>());
+  Expect.isTrue(globalContext["ma1"].isA<MyArray>());
+
+  eval("globalThis.s = 'JS String';");
+  JSString jsS = globalContext["s"] as JSString;
+  JSArray<JSString> jsArr = JSArray<JSString>.withLength(1);
+  jsArr[0] = jsS;
+  MyArray ma2 = MyArray(jsArr);
+  globalContext["ma2"] = ma2;
+  Expect.isTrue(globalContext["ma2"].isA<JSArray<JSString>>());
+  Expect.isTrue(globalContext["ma2"].isA<JSArray<JSNumber>>());
+  Expect.isTrue(globalContext["ma2"].isA<MyArray>());
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A03_t05.dart

@@ -0,0 +1,57 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// If T is a non-primitive JS type like [JSArray] or an interop extension type
+/// on one, this uses an instanceof check using the name or the `@JS` rename of
+/// the given type like `instanceOfString('Array')`. Note that if you rename the
+/// library using the `@JS` annotation, this uses the rename in the instanceof
+/// check like `instanceOfString('library1.JSClass')`.
+///
+/// @description Checks that `isA<>` returns `true` for an appropriate interop
+/// type from a library.
+/// @author [email protected]
+
+@JS("lib1")
+library;
+
+import 'dart:async';
+import 'dart:js_interop';
+import 'dart:js_interop_unsafe';
+import '../../../Utils/expect.dart';
+import '../js_utils.dart';
+
+final completer = Completer<String>();
+
+void complete(String value) {
+  completer.complete(value);
+}
+
+@JS("A")
+extension type ET1(JSObject o) implements JSObject {
+  external int id;
+  external String name;
+}
+
+main() {
+  globalContext["complete"] = complete.toJS;
+  eval(r'''
+    (async () => { 
+      // This is path to the module on tryjobs. May not work locally.
+      globalThis.lib1 = await import('/root_dart/tests/co19/src/LibTest/js_interop/module.js');
+      globalThis.objA = new lib1.A(42, "A form JS");
+    })().then(function(v) {
+      globalThis.complete("");
+    });
+  ''');
+  asyncStart();
+  completer.future.then((_) {
+    ET1 et1 = globalContext["objA"] as ET1;
+    Expect.isTrue(et1.isA<ET1>()); // ET1 interops with lib1.A
+    asyncEnd();
+  });
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A05_t01.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// To determine the JavaScript constructor to use as the second operand in the
+/// `instanceof` check, this function uses the JavaScript name associated with
+/// the extension type, which is either the argument given to the @JS annotation
+/// or the Dart declaration name. So, if you had an interop extension type
+/// `JSClass` that wraps [JSArray] without a rename, this does an
+/// `instanceOfString('JSClass')` check and not an `instanceOfString('Array')`
+/// check.
+///
+/// There are two exceptions to this rule. The first exception is [JSTypedArray].
+/// As `TypedArray` does not exist as a property in JavaScript, this does some
+/// prototype checking to make `isA<JSTypedArray>` do the right thing. The other
+/// exception is [JSAny]. If you do a `isA<JSAny>` check, it will only do a
+/// `null` check.
+///
+/// @description Checks that `isA<JSTypedArray>` returns `true` for a
+/// `JSTypedArray`.
+/// @author [email protected]
+
+import 'dart:js_interop';
+import '../../../Utils/expect.dart';
+
+main() {
+  test(JSFloat32Array());
+  test(JSFloat64Array());
+  test(JSInt16Array());
+  test(JSInt32Array());
+  test(JSInt8Array());
+  test(JSUint16Array());
+  test(JSUint32Array());
+  test(JSUint8Array());
+  test(JSUint8ClampedArray());
+}
+
+test(JSTypedArray ar) {
+  Expect.isFalse(ar.isA<JSArray>());
+  Expect.isTrue(ar.isA<JSTypedArray>());
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A05_t02.dart

@@ -0,0 +1,51 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// To determine the JavaScript constructor to use as the second operand in the
+/// `instanceof` check, this function uses the JavaScript name associated with
+/// the extension type, which is either the argument given to the @JS annotation
+/// or the Dart declaration name. So, if you had an interop extension type
+/// `JSClass` that wraps [JSArray] without a rename, this does an
+/// `instanceOfString('JSClass')` check and not an `instanceOfString('Array')`
+/// check.
+///
+/// There are two exceptions to this rule. The first exception is [JSTypedArray].
+/// As `TypedArray` does not exist as a property in JavaScript, this does some
+/// prototype checking to make `isA<JSTypedArray>` do the right thing. The other
+/// exception is [JSAny]. If you do a `isA<JSAny>` check, it will only do a
+/// `null` check.
+///
+/// @description Checks that `isA<JSAny>` returns `true` for any non-null value.
+/// @author [email protected]
+
+import 'dart:js_interop';
+import 'dart:js_interop_unsafe';
+import '../../../Utils/expect.dart';
+import '../js_utils.dart';
+
+main() {
+  eval(r'''
+    globalThis.i = 1;
+    globalThis.f = 3.14;
+    globalThis.s = "JS String";
+    globalThis.b = true;
+    globalThis.bi = 42n;
+    globalThis.sm = Symbol();
+    globalThis.n = null;
+    globalThis.u = undefined;
+    ''');
+  Expect.isTrue(JSObject().isA<JSAny>());
+  Expect.isTrue(globalContext["i"].isA<JSAny>());
+  Expect.isTrue(globalContext["f"].isA<JSAny>());
+  Expect.isTrue(globalContext["s"].isA<JSAny>());
+  Expect.isTrue(globalContext["b"].isA<JSAny>());
+  Expect.isTrue(globalContext["bi"].isA<JSAny>());
+  Expect.isTrue(globalContext["sm"].isA<JSAny>());
+  Expect.isFalse(globalContext["n"].isA<JSAny>());
+  Expect.isFalse(globalContext["u"].isA<JSAny>());
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A06_t01.dart

@@ -0,0 +1,50 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// Using this method with a `T` that has an object literal constructor will
+/// result in an error as you likely want to use [JSObject] instead.
+///
+/// @description Checks that it is a compile-time error if a type with an object
+/// literal constructor is used as a type argument of `isA`.
+/// @author [email protected]
+
+import 'dart:js_interop';
+
+extension type ET1._(JSObject _) implements JSObject {
+  external ET1({int id, String name});
+}
+
+extension type ET2(JSObject _) implements JSAny {
+  external ET2.n({int id, String name});
+}
+
+@JS("Array")
+extension type ET3(JSArray _) implements JSObject {
+  external ET3.n({int id, String name});
+}
+
+test(JSAny v) {
+  v.isA<ET1>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<ET2>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<ET3>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+}
+
+main() {
+  print(test);
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A07_t01.dart

@@ -0,0 +1,64 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// Using this method with a `T` that wraps a primitive JS type will result in
+/// an error telling you to use the primitive JS type instead.
+///
+/// @description Checks that it is a compile-time error if an extension type on
+/// JS primitive types is used as a type argument of `isA`.
+/// @author [email protected]
+
+import 'dart:js_interop';
+
+extension type MyAny(JSAny _) implements JSAny {}
+
+extension type MyNumber(JSNumber _) implements JSNumber {}
+
+extension type MyString(JSString _) implements JSString {}
+
+extension type MyBoolean(JSBoolean _) implements JSBoolean {}
+
+extension type MyBigInt(JSBigInt _) implements JSBigInt {}
+
+extension type MySymbol(JSSymbol _) implements JSSymbol {}
+
+extension type MyObject(JSObject _) implements JSObject {}
+
+test(JSAny v) {
+  v.isA<MyAny>();
+  v.isA<MyObject>();
+  v.isA<JSNumber>();
+  v.isA<MyNumber>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyString>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyBoolean>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyBigInt>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MySymbol>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+}
+
+main() {
+  print(test);
+}

LibTest/js_interop/JSAnyUtilityExtension/isA_A07_t02.dart

@@ -0,0 +1,63 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion bool isA<T extends JSAny?>()
+/// Whether this [JSAny?] is an instance of the JavaScript type that is declared
+/// by `T`.
+/// ...
+/// Using this method with a `T` that wraps a primitive JS type will result in
+/// an error telling you to use the primitive JS type instead.
+///
+/// @description Checks that it is a compile-time error if an extension type on
+/// JS primitive types is used as a type argument of `isA`. Test extension types
+/// with rename.
+/// @author [email protected]
+
+import 'dart:js_interop';
+
+@JS("Number")
+extension type MyNumber(JSNumber _) implements JSNumber {}
+
+@JS("String")
+extension type MyString(JSString _) implements JSString {}
+
+@JS("Boolean")
+extension type MyBoolean(JSBoolean _) implements JSBoolean {}
+
+@JS("BigInt")
+extension type MyBigInt(JSBigInt _) implements JSBigInt {}
+
+@JS("Symbol")
+extension type MySymbol(JSSymbol _) implements JSSymbol {}
+
+test(JSAny v) {
+  v.isA<MyNumber>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyString>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyBoolean>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MyBigInt>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+
+  v.isA<MySymbol>();
+//  ^^^
+// [analyzer] unspecified
+// [web] unspecified
+}
+
+main() {
+  print(test);
+}