vitest-pool-assemblyscript 0.9.1 → 0.10.1

package/assembly/compare.ts

@@ -99,9 +99,9 @@ export function equalsRtmNamesClear(): void {
  * being compared, enabling path context like ".shape" or ".members" in error messages.
  * Declared global to make it available in all source files without import.
  */
-// @ts-ignore: AS-specific global decorator
+// @ts-ignore: top level decorators are supported in AssemblyScript
 @global
-function __vitest_assemblyscript_equals_path_push(segment: string): void {
+function __vitest_assemblyscript_compare_equals_path_push(segment: string): void {
   equalsPathPush(segment);
 }
 
@@ -112,9 +112,9 @@ function __vitest_assemblyscript_equals_path_push(segment: string): void {
  * On non-Equal, the segment is left on the stack so the path accumulates
  * to the deepest mismatch point.
  */
-// @ts-ignore: AS-specific global decorator
+// @ts-ignore: top level decorators are supported in AssemblyScript
 @global
-function __vitest_assemblyscript_equals_path_pop(): void {
+function __vitest_assemblyscript_compare_equals_path_pop(): void {
   equalsPathPop();
 }
 
@@ -145,7 +145,7 @@ function equalsPathAtSuffix(): string {
  * Declared global so it is available in all source files without import —
  * including transform-injected deep equality methods in user classes.
  */
-// @ts-ignore: AS-specific global decorator
+// @ts-ignore: top level decorators are supported in AssemblyScript
 @global
 export enum __vitest_assemblyscript_EqualityResult {
   Equal,
@@ -233,6 +233,7 @@ function mapEquals<T, U>(actual: T, expected: U): __vitest_assemblyscript_Equali
     // Key types must match exactly — cross-type key comparison is not safe because
     // .has() and .get() depend on the key's hash and equality semantics, which differ
     // across types (e.g. string vs i32 keys have incompatible hash/lookup behavior).
+    // @ts-ignore
     if (nameof<indexof<T>>() != nameof<indexof<U>>()) {
       throw new Error("Map key types must match for deep equality comparison: "
         + nameof<T>() + " and " + nameof<U>()
@@ -248,6 +249,7 @@ function mapEquals<T, U>(actual: T, expected: U): __vitest_assemblyscript_Equali
     // actual's native value type. This lets us iterate expected's keys and look them
     // up in actual, while equals() handles cross-type value comparison naturally
     // (e.g. valueof<T>=i32 vs valueof<U>=f64).
+    // @ts-ignore
     const castActual = changetype<Map<indexof<U>, valueof<T>>>(actual);
 
     // instanceof needed after changetype for the compiler to resolve Map methods
@@ -616,13 +618,13 @@ export function equals<T, U>(actual: T, expected: U): __vitest_assemblyscript_Eq
     }
   }
 
-  // @ts-ignore
   // User-defined reference types: delegate to compiler transform-injected deep equality
   // method. Uses hard-coded method name because using a variable like `actual[DEEP_EQ_FUNC]`
   // requires the class to define an index signature.
   // Cast to NonNullable<T> because AS doesn't narrow nullability from the changetype-based
   // null checks above — it requires explicit type narrowing to call methods on nullable types.
   // Safe because both-null and one-null cases return early above.
+  // @ts-ignore
   if (isDefined(actual.__vitest_assemblyscript_deep_equals)) {
     const nonNullActual = <NonNullable<T>>actual;
     // @ts-ignore
@@ -639,15 +641,12 @@ export function equals<T, U>(actual: T, expected: U): __vitest_assemblyscript_Eq
  * Global bridge for the deep-equals compiler transform.
  *
  * Injected deep equality methods in user classes call this function for per-field
- * comparisons. Declared global to make it available in all source files without import,
- * solving the afterParse import resolution limitation (injected import statements
- * are not processed by the AS compiler).
+ * comparisons. Declared global to make it available in all user source files without import.
+ * (solves the `afterParse` import resolution limitation where injected import statements
+ * are not processed by the AS compiler)
  *
  * Returns __vitest_assemblyscript_EqualityResult so injected methods can propagate type mismatch information
  * from nested comparisons back to the top-level matcher.
- *
- * Loaded into the compilation transitively: user test imports
- * vitest-pool-assemblyscript/assembly → index.ts → compare.ts.
  */
 // @ts-ignore
 @global

package/assembly/describe.ts

@@ -28,7 +28,7 @@ declare function __end_register_suite(name: string): void;
 export function describe<T = TestCallback, U = TestOptions>(
   name: string,
   optionsOrFn: T,
-  // @ts-ignore
+  // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
   fnOrOptions: U = DEFAULT_TEST_OPTIONS  // defaults all undefined here, merged with config in JS
 ): void {
   let fn: TestCallback;
@@ -62,7 +62,7 @@ function describeWithMergedOption<T = TestCallback, U = TestOptions>(
   name: string,
   optionToMerge: TestOptions,
   optionsOrFn: T,
-  // @ts-ignore
+  // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
   fnOrOptions: U = DEFAULT_TEST_OPTIONS
 ): void {
   let fn: TestCallback;
@@ -87,7 +87,7 @@ export namespace describe {
   export function skip<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return describeWithMergedOption(name, TestOptions.skip(), optionsOrFn, fnOrOptions);
@@ -96,7 +96,7 @@ export namespace describe {
   export function only<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return describeWithMergedOption(name, TestOptions.only(), optionsOrFn, fnOrOptions);

package/assembly/expect.ts

@@ -11,7 +11,12 @@ import {
   InequalityOperation,
   truthyOrFalsey,
 } from './compare';
-import { isNull, nan, stringifyValue } from './utils';
+import {
+  isNull,
+  nan,
+  stringifyValue,
+  STRINGIFY_SHORT_FORM_BUDGET
+} from './utils';
 
 // @external functions are imported to the WASM execution environment from pool code
 
@@ -23,10 +28,11 @@ declare function __assertion_pass(): void;
 @external("__as_pool_env__", "__assertion_fail")
 declare function __assertion_fail<T>(
   msg: string,
-  typeName: string,
+  actualTypeName: string,
+  expectedTypeName: string,
   valuesProvided: bool,
-  actual?: T,
-  expected?: T
+  actual?: string,
+  expected?: string
 ): void;
 
 // @ts-ignore: top level decorators are supported in AssemblyScript
@@ -306,6 +312,7 @@ abstract class BaseExpectMatcher<T> {
     equalsRtmNamesClear();
     const result = equals(this.actual, val);
     const path = equalsPathString();
+    // @ts-ignore: global
     const isRtm = result == __vitest_assemblyscript_EqualityResult.RuntimeTypeMismatch;
 
     let suffix = "";
@@ -316,6 +323,7 @@ abstract class BaseExpectMatcher<T> {
       suffix = " (differs at " + path + ")";
     }
 
+    // @ts-ignore: global
     this.assertComparison(result == __vitest_assemblyscript_EqualityResult.Equal, this.actual, val, "to deeply equal", true, true, suffix, isRtm);
   }
   
@@ -340,6 +348,7 @@ abstract class BaseExpectMatcher<T> {
     equalsRtmNamesClear();
     const result = equals(this.actual, val);
     const path = equalsPathString();
+    // @ts-ignore: global
     const isRtm = result == __vitest_assemblyscript_EqualityResult.RuntimeTypeMismatch;
 
     let suffix = "";
@@ -350,6 +359,7 @@ abstract class BaseExpectMatcher<T> {
       suffix = " (differs at " + path + ")";
     }
 
+    // @ts-ignore: global
     this.assertComparison(result == __vitest_assemblyscript_EqualityResult.Equal, this.actual, val, "to strictly equal", true, true, suffix, isRtm);
   }
 
@@ -459,10 +469,10 @@ abstract class BaseExpectMatcher<T> {
         const nonNullActual = <NonNullable<T>>this.actual;
 
         if (isFloat<U>()) {
-          // @ts-ignore: .length is i32; use closeTo for float comparison
+          // @ts-ignore: TS doesn't know that nonNullActual is still array-like
           this.assertComparison<i32, U>(closeTo<i32, U>(nonNullActual.length, length), nonNullActual.length, length, "to have length", true);
         } else {
-          // @ts-ignore: .length is i32; compare as integers
+          // @ts-ignore: TS doesn't know that nonNullActual is still array-like
           this.assertComparison<i32, U>(identical<i32, U>(nonNullActual.length, length), nonNullActual.length, length, "to have length", true);
         }
       } else {
@@ -486,31 +496,39 @@ abstract class BaseExpectMatcher<T> {
       __assertion_pass();
     } else {
       const notStr = this.isInverted ? "not " : "";
-      // For runtime type mismatches, show the top-level type name only — the mismatched
-      // types in the suffix are the useful information, not field contents of differently-typed
-      // objects. Uses __vitest_assemblyscript_typename (virtual dispatch gives runtime name)
-      // with nameof fallback for types without injection (containers, primitives).
-      // For value mismatches, full stringification shows what values differ.
-      let actualStr: string;
-      let expectedStr: string;
-      if (isRtm) {
+
+      // Type strings use __vitest_assemblyscript_typename (virtual dispatch gives runtime name)
+      // with `nameof` fallback for types without injection (containers, primitives)
+      // @ts-ignore
+      const actualType: string = isDefined(actual.__vitest_assemblyscript_typename)
         // @ts-ignore
-        actualStr = isDefined(actual.__vitest_assemblyscript_typename)
-          // @ts-ignore
-          ? (<NonNullable<U>>actual).__vitest_assemblyscript_typename()
-          : nameof<U>();
+        ? (<NonNullable<U>>actual).__vitest_assemblyscript_typename()
+        : nameof<U>();
+      // @ts-ignore
+      const expectedType: string = isDefined(expected.__vitest_assemblyscript_typename)
         // @ts-ignore
-        expectedStr = isDefined(expected.__vitest_assemblyscript_typename)
-          // @ts-ignore
-          ? (<NonNullable<V>>expected).__vitest_assemblyscript_typename()
-          : nameof<V>();
+        ? (<NonNullable<V>>expected).__vitest_assemblyscript_typename()
+        : nameof<V>();
+
+      let actualShort: string = "";
+      let expectedShort: string = "";
+      let actualDiff: string = "";
+      let expectedDiff: string = "";
+      
+      if (isRtm) {
+        // For runtime type mismatches, show the top-level type name only
+        actualShort = actualDiff = actualType;
+        expectedShort = expectedDiff = expectedType;
       } else {
-        actualStr = stringifyValue(actual);
-        expectedStr = stringifyValue(expected);
+        // For value mismatches, stringification shows what values differ
+        actualShort = stringifyValue(actual, false, 0, STRINGIFY_SHORT_FORM_BUDGET);
+        expectedShort = stringifyValue(expected, false, 0, STRINGIFY_SHORT_FORM_BUDGET);
+        actualDiff = stringifyValue(actual, true);
+        expectedDiff = stringifyValue(expected, true);
       }
-      const msg = `expected ${actualStr} ${notStr}${methodStr}${printExpected ? ` ${expectedStr}` : ""}${suffix}`;
+      const msg = `expected ${actualShort} ${notStr}${methodStr}${printExpected ? ` ${expectedShort}` : ""}${suffix}`;
 
-      __assertion_fail<string>(msg, nameof<U>() + " " + nameof<V>(), provideDiff, actualStr, expectedStr);
+      __assertion_fail<string>(msg, actualType, expectedType, provideDiff, actualDiff, expectedDiff);
   
       // Abort on failure - terminates WASM execution - must be called from WASM.
       // Imported abort handler will handle this and mark the test as failed.

package/assembly/test.ts

@@ -27,7 +27,7 @@ export type TestCallback = () => void;
 export function test<T = TestCallback, U = TestOptions>(
   name: string,
   optionsOrFn: T,
-  // @ts-ignore
+  // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
   fnOrOptions: U = DEFAULT_TEST_OPTIONS  // defaults all undefined here, merged with config & suite in JS
 ): void {
   let fn: TestCallback;
@@ -58,7 +58,7 @@ function testWithMergedOption<T = TestCallback, U = TestOptions>(
   name: string,
   optionToMerge: TestOptions,
   optionsOrFn: T,
-  // @ts-ignore
+  // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
   fnOrOptions: U = DEFAULT_TEST_OPTIONS
 ): void {
   let fn: TestCallback;
@@ -83,7 +83,7 @@ export namespace test {
   export function skip<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.skip(), optionsOrFn, fnOrOptions);
@@ -92,7 +92,7 @@ export namespace test {
   export function only<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.only(), optionsOrFn, fnOrOptions);
@@ -101,7 +101,7 @@ export namespace test {
   export function fails<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.fails(), optionsOrFn, fnOrOptions);
@@ -111,7 +111,7 @@ export namespace test {
 export function it<T = TestCallback, U = TestOptions>(
   name: string,
   optionsOrFn: T,
-  // @ts-ignore
+  // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
   fnOrOptions: U = DEFAULT_TEST_OPTIONS
 ): void {
   return test(name, optionsOrFn, fnOrOptions);
@@ -121,7 +121,7 @@ export namespace it {
   export function skip<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.skip(), optionsOrFn, fnOrOptions);
@@ -130,7 +130,7 @@ export namespace it {
   export function only<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.only(), optionsOrFn, fnOrOptions);
@@ -139,7 +139,7 @@ export namespace it {
   export function fails<T = TestCallback, U = TestOptions>(
     name: string,
     optionsOrFn: T,
-    // @ts-ignore
+    // @ts-ignore: TS2322 ('U' could be instantiated with an arbitrary type) doesn't apply to AS
     fnOrOptions: U = DEFAULT_TEST_OPTIONS
   ): void {
     return testWithMergedOption(name, TestOptions.fails(), optionsOrFn, fnOrOptions);