fix(matcher): change MatchResult interface

_e2e/expect_test.ts

@@ -1225,5 +1225,7 @@ test("passes when stringified value to be", async () => {
     },
   });
   expect(null).stringify.toBe("null");
-  await expect(Promise.resolve("test ")).resolves.stringify.trim.toBe("test");
+  await expect(Promise.resolve("test ")).resolves.stringify.trim.toBe(
+    "test",
+  );
 });

expect/_utils.ts

@@ -4,8 +4,7 @@
 import { stringifyResult } from "../helper/format.ts";
 import { AssertionError } from "../deps.ts";
 
-import type { Matcher, RenamedMatchResult } from "../matcher/types.ts";
-import type { Rename } from "../_types.ts";
+import type { Matcher, MatchResult } from "../matcher/types.ts";
 import type {
   PostModifierContext,
   PostModifierResult,
@@ -15,7 +14,7 @@ import type {
 type Result = {
   actual: unknown;
   matcherArgs: readonly unknown[];
-  actualResult: unknown;
+  resultActual: unknown;
   actualHint: string;
   expected: unknown;
   expectedHint: string;
@@ -46,13 +45,13 @@ type PreModifierContext = {
     matcherArgs: readonly unknown[];
     matcher: Matcher;
   };
-  returns: Rename<PreModifierResult, "actual", "actualResult">;
+  returns: PreModifierResult;
 };
 
 type ExpectContext = {
   expectContext: {
     actual: Result["actual"];
-    actualResult: unknown;
+    resultActual: unknown;
     matcher: Matcher;
     matcherArgs: readonly unknown[];
     actualHint: string;
@@ -67,7 +66,7 @@ type ExpectContext = {
   matcherContext: {
     name: string;
     args: Pick<Result, "actual" | "matcherArgs">;
-    returns: RenamedMatchResult;
+    returns: MatchResult;
   };
 };
 
@@ -91,12 +90,12 @@ function mergeContext(
     ...expectContext,
     ...preModifierContexts.reduce(
       returnReducer,
-      {} as PostModifierResult,
+      {} as PreModifierResult,
     ),
     ...matcherContext.returns,
     ...postModifierContexts.reduce(
       returnReducer,
-      {} as Rename<PreModifierResult, "actual", "actualResult">,
+      {} as PreModifierResult,
     ),
   };
 }

expect/_utils_test.ts

@@ -13,7 +13,7 @@ Deno.test("assert", () => {
         expected: "tes",
         expectedHint: "Expected:",
         matcherArgs: [],
-        actualResult: "test",
+        resultActual: "test",
         matcherName: "toBe",
         postModifierNames: [],
         preModifierNames: [],
@@ -27,7 +27,7 @@ Deno.test("mergeContext", () => {
     mergeContext({
       expectContext: {
         actual: "test",
-        actualResult: "test",
+        resultActual: "test",
         actualHint: "Actual:",
         expectedHint: "Expected:",
         matcher,
@@ -54,7 +54,7 @@ Deno.test("mergeContext", () => {
       expectedHint: "Expected:",
       matcherArgs: [],
       expected: "test",
-      actualResult: "test",
+      resultActual: "test",
       pass: false,
     },
   );
@@ -63,7 +63,7 @@ Deno.test("mergeContext", () => {
     mergeContext({
       expectContext: {
         actual: Promise.resolve("test"),
-        actualResult: Promise.resolve("test"),
+        resultActual: Promise.resolve("test"),
         actualHint: "Actual:",
         expectedHint: "Expected:",
         matcher,
@@ -77,8 +77,8 @@ Deno.test("mergeContext", () => {
           matcherArgs: ["test"],
         },
         returns: {
-          "expected": "test",
-          "pass": true,
+          expected: "test",
+          pass: true,
         },
       },
       preModifierContexts: [{
@@ -89,18 +89,18 @@ Deno.test("mergeContext", () => {
           matcherArgs: ["test"],
         },
         returns: {
-          actualResult: "test",
+          actual: "test",
         },
       }],
     }),
     {
-      actual: Promise.resolve("test"),
+      actual: "test",
       matcher,
       actualHint: "Actual:",
       expectedHint: "Expected:",
       matcherArgs: ["test"],
       expected: "test",
-      actualResult: "test",
+      resultActual: Promise.resolve("test"),
       pass: true,
     },
   );

expect/expect.ts

@@ -4,7 +4,7 @@
 import { jestMatcherMap } from "../matcher/preset.ts";
 import { jestModifierMap } from "../modifier/preset.ts";
 import { isPromise } from "../deps.ts";
-import { head, last, rename } from "../matcher/utils.ts";
+import { head, last } from "../matcher/utils.ts";
 import {
   assert,
   DEFAULT_ACTUAL_HINT,
@@ -195,7 +195,7 @@ function defineExpect<
           const expectContext = {
             ...preModifierArgs,
             actual,
-            actualResult: actual,
+            resultActual: actual,
             actualHint: DEFAULT_ACTUAL_HINT,
             expectedHint: DEFAULT_EXPECTED_HINT,
           };
@@ -213,50 +213,42 @@ function defineExpect<
                   lastResult.then(async ({ returns }) => ({
                     name,
                     args: {
-                      actual: returns.actualResult,
+                      actual: returns.actual,
                       ...preModifierArgs,
                     },
-                    returns: rename(
-                      await fn(
-                        returns.actualResult,
-                        preModifierArgs,
-                      ),
-                      "actual",
-                      "actualResult",
+                    returns: await fn(
+                      returns.actual,
+                      preModifierArgs,
                     ),
                   })),
                 ];
               } else {
-                const _actual = lastResult?.returns.actualResult ?? actual;
+                const _actual = lastResult?.returns.actual ?? actual;
                 const value = fn(
                   _actual,
                   preModifierArgs,
                 );
 
+                /** utility for make shared value */
+                const makeShared = (
+                  returns: PreModifierResult<unknown>,
+                ): PreModifierContext => ({
+                  name,
+                  args: {
+                    actual: _actual,
+                    ...preModifierArgs,
+                  },
+                  returns,
+                });
+
                 if (isPromise(value)) {
                   usePromise = true;
                   return [
                     ...acc,
-                    value.then((_context) => {
-                      return {
-                        name,
-                        args: {
-                          actual: _actual,
-                          ...preModifierArgs,
-                        },
-                        returns: rename(_context, "actual", "actualResult"),
-                      };
-                    }),
+                    value.then(makeShared),
                   ];
                 }
-                return [...acc, {
-                  name,
-                  args: {
-                    actual: _actual,
-                    ...preModifierArgs,
-                  },
-                  returns: rename(value, "actual", "actualResult"),
-                }];
+                return [...acc, makeShared(value)];
               }
             },
             [] as (
@@ -271,18 +263,17 @@ function defineExpect<
             preModifierContexts: ExpectContext["preModifierContexts"],
           ) => {
             const matcherArgs = {
-              actual: last(preModifierContexts)?.returns.actualResult ?? actual,
+              actual: last(preModifierContexts)?.returns.actual ?? actual,
               matcherArgs: args,
             };
-            const _matchResult = matcher(
+            const matchResult = matcher(
               matcherArgs.actual,
               ...matcherArgs.matcherArgs,
             );
-            const matchResult = rename(_matchResult, "actual", "actualResult");
 
             const postModifierArgs = {
               ...matcherArgs,
-              actualResult: matchResult.actualResult,
+              resultActual: matchResult.resultActual,
               actualHint: matchResult.actualHint ?? DEFAULT_ACTUAL_HINT,
               matcher,
               expectedHint: matchResult.expectedHint ?? DEFAULT_EXPECTED_HINT,
@@ -302,19 +293,21 @@ function defineExpect<
               [] as ExpectContext["postModifierContexts"],
             );
 
+            const matcherName = String(name);
+
             const result = mergeContext({
               expectContext,
               preModifierContexts,
               matcherContext: {
-                name: String(name),
+                name: matcherName,
                 args: matcherArgs,
                 returns: matchResult,
               },
               postModifierContexts,
             });
             return assert({
               ...result,
-              matcherName: String(name),
+              matcherName,
               preModifierNames: pre.map(head),
               postModifierNames: post.map(head),
             });

helper/format.ts

@@ -48,7 +48,7 @@ type StringifyResultArgs = {
   matcherName: string;
   matcherArgs: readonly unknown[];
 
-  actualResult: unknown;
+  resultActual: unknown;
   expected: unknown;
   expectedHint: string;
   actualHint: string;
@@ -57,21 +57,21 @@ type StringifyResultArgs = {
 };
 
 type StringifyAssertArgs = {
-  actualResult: unknown;
+  resultActual: unknown;
   expected: unknown;
   expectedHint?: string;
   actualHint?: string;
 };
 
 function stringifyAssert({
-  actualResult,
+  resultActual,
   expected,
   expectedHint,
   actualHint,
 }: Required<StringifyAssertArgs>): string {
   return nestText(
     `${actualHint}
-${nestText(green(stringify(actualResult)), 2)}
+${nestText(green(stringify(resultActual)), 2)}
 ${expectedHint}
 ${nestText(red(stringify(expected)), 2)}
 `,
@@ -84,7 +84,7 @@ function stringifyResult(
     actual,
     matcherArgs,
     matcherName,
-    actualResult,
+    resultActual,
     expected,
     expectedHint,
     actualHint,
@@ -104,7 +104,7 @@ function stringifyResult(
 
 ${
     stringifyAssert({
-      actualResult,
+      resultActual,
       actualHint,
       expected,
       expectedHint,

matcher/to_be_close_to.ts

@@ -26,7 +26,7 @@ function toBeCloseTo(
   const expectedRounded = roundTo(expected, precision);
   return {
     actualHint: `Actual rounded ${precision} digit:`,
-    actual: actualRounded,
+    resultActual: actualRounded,
     pass: actualRounded === expectedRounded,
     expectedHint: `Expected rounded ${precision} digit:`,
     expected: expectedRounded,

matcher/to_be_close_to_test.ts

@@ -89,14 +89,14 @@ Deno.test({
     assertEquals(toBeCloseTo(0.1, 0.101, 3), {
       pass: false,
       actualHint: `Actual rounded 3 digit:`,
-      actual: 0.1,
+      resultActual: 0.1,
       expected: 0.101,
       expectedHint: `Expected rounded 3 digit:`,
     });
     assertEquals(toBeCloseTo(0.500001, 0.500003, 5), {
       pass: true,
       actualHint: `Actual rounded 5 digit:`,
-      actual: 0.5,
+      resultActual: 0.5,
       expected: 0.5,
       expectedHint: `Expected rounded 5 digit:`,
     });

matcher/to_be_error.ts

@@ -53,7 +53,7 @@ function toBeError(
   if (isUndefined(messageIncludes)) {
     const msg = "error name:";
     return {
-      actual: actual.name,
+      resultActual: actual.name,
       actualHint: `Actual ${msg}`,
       pass: actual.name === ErrorClass.name,
       expected: ErrorClass.name,
@@ -63,7 +63,7 @@ function toBeError(
 
   return {
     pass: actual.message.includes(messageIncludes),
-    actual: actual.message,
+    resultActual: actual.message,
     actualHint: "Actual error message:",
     expected: messageIncludes,
     expectedHint: "Expected to includes:",