♻️ Rename primitive to primitive-union
`getMatcher` / `getMatcherW` become `getPrimitiveUnionMatcher` / `getPrimitiveUnionMatcherW`; `src/primitive.ts` and its test move to `src/primitive-union.*`. The `Union` suffix mirrors `getTaggedUnionMatcher`.
This commit is contained in:
tmu committed
1 parent
0727117afb
commit
02f736507c
10 files changed
+97
-83
No files matched your search
@@ -0,0 +1,761 @@
|
||||
import { strict as assert } from "node:assert";
|
||||
import path from "node:path";
|
||||
import { test } from "node:test";
|
||||
|
||||
import { expectTypeOf } from "expect-type";
|
||||
|
||||
import {
|
||||
type CompletionTarget,
|
||||
LspSession,
|
||||
} from "#test-utils/lsp-completion.ts";
|
||||
|
||||
import {
|
||||
getPrimitiveUnionMatcher,
|
||||
getPrimitiveUnionMatcherW,
|
||||
} from "./primitive-union.ts";
|
||||
|
||||
// ============================================================================
|
||||
// API: getPrimitiveUnionMatcher — ✔️ Exhaustive / ✔️ ReturnsStrict
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcher: exhaustive pattern infers one common return type", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<"a" | "b">();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 1;
|
||||
},
|
||||
b: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b">();
|
||||
assert.equal(s, "b");
|
||||
return 2;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
// ✔️ ReturnsStrict: R is the best common return type, not a widening union.
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b") => number>();
|
||||
// ❌ a value outside T must not be accepted by the matcher
|
||||
expectTypeOf<"c">().not.toExtend<Parameters<typeof matcher>[0]>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher("b"), 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: dispatches on numeric literal keys", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<1 | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
1: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<1>();
|
||||
// A numeric key must not reach its handler as the string `"1"`.
|
||||
assert.equal(n, 1);
|
||||
return n + 1;
|
||||
},
|
||||
2: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<2>();
|
||||
assert.equal(n, 2);
|
||||
return n * 10;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: 1 | 2) => number>();
|
||||
assert.equal(matcher(1), 2);
|
||||
assert.equal(matcher(2), 20);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: dispatches on mixed string and numeric keys", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<"a" | "b" | 1 | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 1;
|
||||
},
|
||||
b: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b">();
|
||||
assert.equal(s, "b");
|
||||
return 2;
|
||||
},
|
||||
1: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<1>();
|
||||
assert.equal(n, 1);
|
||||
return 10;
|
||||
},
|
||||
2: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<2>();
|
||||
assert.equal(n, 2);
|
||||
return 20;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | 1 | 2) => number>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher("b"), 2);
|
||||
assert.equal(matcher(1), 10);
|
||||
assert.equal(matcher(2), 20);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: dispatches on boolean literals", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<boolean>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<true>();
|
||||
// The `true` key is a property name; the handler must still be
|
||||
// called with the boolean `true`, not the string `"true"`.
|
||||
assert.equal(s, true);
|
||||
return 1;
|
||||
},
|
||||
false: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<false>();
|
||||
assert.equal(s, false);
|
||||
return 2;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: boolean) => number>();
|
||||
assert.equal(matcher(true), 1);
|
||||
assert.equal(matcher(false), 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: dispatches on null and undefined", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<null | undefined>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<null>();
|
||||
assert.equal(s, null);
|
||||
return "null";
|
||||
},
|
||||
undefined: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<undefined>();
|
||||
assert.equal(s, undefined);
|
||||
return "undefined";
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: null | undefined) => string>();
|
||||
assert.equal(matcher(null), "null");
|
||||
assert.equal(matcher(undefined), "undefined");
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// API: getPrimitiveUnionMatcher — ❌ Exhaustive (fallback) / ✔️ ReturnsStrict
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcher: a `_` fallback receives the unhandled keys", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<"a" | "b" | "c">();
|
||||
|
||||
// Act
|
||||
const matcher = factory(
|
||||
{
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 1 as const;
|
||||
},
|
||||
},
|
||||
(s) => {
|
||||
// The fallback sees only the keys `a` did not handle.
|
||||
expectTypeOf(s).toEqualTypeOf<"b" | "c">();
|
||||
assert.ok(s === "b" || s === "c");
|
||||
return 2 as const;
|
||||
},
|
||||
);
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | "c") => 1 | 2>();
|
||||
// ❌ a value outside T must not be accepted by the matcher
|
||||
expectTypeOf<"d">().not.toExtend<Parameters<typeof matcher>[0]>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher("b"), 2);
|
||||
assert.equal(matcher("c"), 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: a `_` fallback routes mixed string and numeric gaps", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<"a" | "b" | 1 | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory(
|
||||
{
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return "A";
|
||||
},
|
||||
1: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<1>();
|
||||
assert.equal(n, 1);
|
||||
return "one";
|
||||
},
|
||||
},
|
||||
(s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b" | 2>();
|
||||
// The gap mixes a string and a number, so the number must reach the
|
||||
// fallback as `2`, never as its key text `"2"`.
|
||||
assert.ok(s === "b" || s === 2);
|
||||
return "fallback";
|
||||
},
|
||||
);
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | 1 | 2) => string>();
|
||||
assert.equal(matcher("a"), "A");
|
||||
assert.equal(matcher("b"), "fallback");
|
||||
assert.equal(matcher(1), "one");
|
||||
assert.equal(matcher(2), "fallback");
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: a `_` fallback receives unhandled boolean and nullish keys", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<
|
||||
"a" | true | false | null | undefined
|
||||
>();
|
||||
|
||||
// Act
|
||||
const matcher = factory(
|
||||
{
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 1 as const;
|
||||
},
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<null>();
|
||||
assert.equal(s, null);
|
||||
return 2 as const;
|
||||
},
|
||||
},
|
||||
(s) => {
|
||||
// `true` and `false` are keyed as `"true"`/`"false"` but the
|
||||
// fallback still sees them as booleans.
|
||||
expectTypeOf(s).toEqualTypeOf<true | false | undefined>();
|
||||
assert.ok(s === true || s === false || s === undefined);
|
||||
return 3 as const;
|
||||
},
|
||||
);
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<
|
||||
(shape: "a" | true | false | null | undefined) => 1 | 2 | 3
|
||||
>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher(true), 3);
|
||||
assert.equal(matcher(false), 3);
|
||||
assert.equal(matcher(null), 2);
|
||||
assert.equal(matcher(undefined), 3);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// API: getPrimitiveUnionMatcherW — ✔️ Exhaustive / ❌ ReturnsStrict
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcherW: exhaustive pattern widens to the union of handler returns", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<"x" | "y">();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
x: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"x">();
|
||||
assert.equal(s, "x");
|
||||
return 1 as const;
|
||||
},
|
||||
y: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"y">();
|
||||
assert.equal(s, "y");
|
||||
return "two" as const;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
// ❌ ReturnsStrict: mixed handler returns widen to their union.
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: "x" | "y") => 1 | "two">();
|
||||
// ❌ a value outside T must not be accepted by the matcher
|
||||
expectTypeOf<"z">().not.toExtend<Parameters<typeof matcher>[0]>();
|
||||
assert.equal(matcher("x"), 1);
|
||||
assert.equal(matcher("y"), "two");
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcherW: dispatches on mixed string and numeric keys", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<"a" | "b" | 1 | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return "A" as const;
|
||||
},
|
||||
b: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b">();
|
||||
assert.equal(s, "b");
|
||||
return "B" as const;
|
||||
},
|
||||
1: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<1>();
|
||||
assert.equal(n, 1);
|
||||
return 10 as const;
|
||||
},
|
||||
2: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<2>();
|
||||
assert.equal(n, 2);
|
||||
return 20 as const;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<
|
||||
(shape: "a" | "b" | 1 | 2) => "A" | "B" | 10 | 20
|
||||
>();
|
||||
assert.equal(matcher("a"), "A");
|
||||
assert.equal(matcher("b"), "B");
|
||||
assert.equal(matcher(1), 10);
|
||||
assert.equal(matcher(2), 20);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcherW: exhaustive boolean and nullish widen to the union", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<boolean | null | undefined>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<true>();
|
||||
assert.equal(s, true);
|
||||
return "yes" as const;
|
||||
},
|
||||
false: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<false>();
|
||||
assert.equal(s, false);
|
||||
return "no" as const;
|
||||
},
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<null>();
|
||||
assert.equal(s, null);
|
||||
return 0 as const;
|
||||
},
|
||||
undefined: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<undefined>();
|
||||
assert.equal(s, undefined);
|
||||
return 1 as const;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<
|
||||
(shape: boolean | null | undefined) => "yes" | "no" | 0 | 1
|
||||
>();
|
||||
assert.equal(matcher(true), "yes");
|
||||
assert.equal(matcher(false), "no");
|
||||
assert.equal(matcher(null), 0);
|
||||
assert.equal(matcher(undefined), 1);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// API: getPrimitiveUnionMatcherW — ❌ Exhaustive (fallback) / ❌ ReturnsStrict
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcherW: a `_` fallback widens gaps into the union", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<"x" | "y" | "z">();
|
||||
|
||||
// Act
|
||||
const matcher = factory(
|
||||
{
|
||||
x: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"x">();
|
||||
assert.equal(s, "x");
|
||||
return 1 as const;
|
||||
},
|
||||
},
|
||||
(s) => {
|
||||
// The fallback sees only the keys `x` did not handle.
|
||||
expectTypeOf(s).toEqualTypeOf<"y" | "z">();
|
||||
// Returning the shape verbatim lets the `Assert` block check the
|
||||
// exact value dispatch passed.
|
||||
return s;
|
||||
},
|
||||
);
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<
|
||||
(shape: "x" | "y" | "z") => 1 | "y" | "z"
|
||||
>();
|
||||
// ❌ a value outside T must not be accepted by the matcher
|
||||
expectTypeOf<"w">().not.toExtend<Parameters<typeof matcher>[0]>();
|
||||
assert.equal(matcher("x"), 1);
|
||||
assert.equal(matcher("y"), "y");
|
||||
assert.equal(matcher("z"), "z");
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcherW: a `_` fallback widens mixed string and numeric returns", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<"a" | "b" | 1 | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory(
|
||||
{
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return "A" as const;
|
||||
},
|
||||
1: (n) => {
|
||||
expectTypeOf(n).toEqualTypeOf<1>();
|
||||
assert.equal(n, 1);
|
||||
return 10 as const;
|
||||
},
|
||||
},
|
||||
(s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b" | 2>();
|
||||
// The number must arrive as `2`, not as its key text `"2"`.
|
||||
assert.ok(s === "b" || s === 2);
|
||||
// Returning the shape verbatim lets the `Assert` block check the
|
||||
// exact value dispatch passed.
|
||||
return s;
|
||||
},
|
||||
);
|
||||
|
||||
// Assert
|
||||
// ❌ ReturnsStrict: mixed handler returns widen to their union.
|
||||
expectTypeOf(matcher).toEqualTypeOf<
|
||||
(shape: "a" | "b" | 1 | 2) => "A" | 10 | "b" | 2
|
||||
>();
|
||||
assert.equal(matcher("a"), "A");
|
||||
assert.equal(matcher("b"), "b");
|
||||
assert.equal(matcher(1), 10);
|
||||
assert.equal(matcher(2), 2);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Factory contracts — calls that must not compile
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcher factory rejects patterns outside its contract", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<"a" | "b">();
|
||||
|
||||
// Act / Assert — the calls below must not compile.
|
||||
// `Parameters<typeof factory>[0]` resolves only the *last* overload, so it
|
||||
// is not a sound "rejected" oracle (an accepted partial pattern does not
|
||||
// extend it either); the call sites are the oracle instead.
|
||||
factory({
|
||||
a: () => 1,
|
||||
b: () => 2,
|
||||
// @ts-expect-error `c` is not part of the universe `"a" | "b"`
|
||||
c: () => 3,
|
||||
});
|
||||
// @ts-expect-error a gap without a `_` fallback is not exhaustive
|
||||
factory({ a: () => 1 });
|
||||
// @ts-expect-error a `string` fallback does not fit the `number` handler
|
||||
factory({ a: () => 1 }, () => "x");
|
||||
// @ts-expect-error a fallback is redundant once the map covers the universe
|
||||
factory({ a: () => 1, b: () => 2 }, () => 0);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher factory rejects non-exhaustive boolean and nullish maps", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<boolean | null | undefined>();
|
||||
|
||||
// Act / Assert — the calls below must not compile
|
||||
// @ts-expect-error only `true` is handled; `false`, `null`, `undefined` are not
|
||||
factory({ true: () => 1 });
|
||||
// @ts-expect-error `null` and `undefined` are not handled
|
||||
factory({ true: () => 1, false: () => 2 });
|
||||
factory(
|
||||
// @ts-expect-error a fallback is redundant once the map covers the universe
|
||||
{
|
||||
true: () => 1,
|
||||
false: () => 2,
|
||||
null: () => 3,
|
||||
undefined: () => 4,
|
||||
},
|
||||
() => 0,
|
||||
);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: an open universe keeps the fallback's remainder open", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<string>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({ a: () => 1 }, (s) => {
|
||||
// The map's literal keys do not close an open universe, so the
|
||||
// remainder stays `string` and the fallback is not redundant.
|
||||
expectTypeOf(s).toEqualTypeOf<string>();
|
||||
// A strict pattern fixes one `R` for every handler, so this fallback
|
||||
// cannot return its shape; `typeof` is the strongest claim the value
|
||||
// makes on its own — any string passes, including `""`.
|
||||
assert.equal(typeof s, "string");
|
||||
return 2 as const;
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: string) => number>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher("b"), 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcherW factory rejects patterns outside its contract", () => {
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcherW<"x" | "y">();
|
||||
|
||||
// Act / Assert — the calls below must not compile
|
||||
factory({
|
||||
x: () => 1 as const,
|
||||
y: () => 2 as const,
|
||||
// @ts-expect-error `z` is not part of the universe `"x" | "y"`
|
||||
z: () => 3 as const,
|
||||
});
|
||||
// @ts-expect-error a gap without a `_` fallback is not exhaustive
|
||||
factory({ x: () => 1 as const });
|
||||
// @ts-expect-error a fallback is redundant once the map covers the universe
|
||||
factory({ x: () => 1 as const, y: () => 2 as const }, () => 0);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Dispatch — runtime behavior
|
||||
// ============================================================================
|
||||
|
||||
test("getPrimitiveUnionMatcher: an unhandled shape throws without a fallback", () => {
|
||||
// Arrange — an open universe types its handler map as an index signature,
|
||||
// so the type system cannot prove the runtime map is exhaustive.
|
||||
const handlers: Record<string, (shape: unknown) => number> = {
|
||||
a: (shape) => {
|
||||
// The raw shape reaches the handler, not the property key's text.
|
||||
assert.equal(shape, "a");
|
||||
return 1;
|
||||
},
|
||||
};
|
||||
const matcher = getPrimitiveUnionMatcher<string>()(handlers);
|
||||
|
||||
// Act / Assert
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.throws(() => matcher("b"), /Unhandled shape: b/);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: an unhandled boolean shape throws without a fallback", () => {
|
||||
// Arrange — an `string | boolean` universe widens its handler map to an
|
||||
// index signature, so the runtime map's exhaustiveness is not provable.
|
||||
const handlers: Record<string, (shape: unknown) => number> = {
|
||||
true: (shape) => {
|
||||
// `true` indexes the map as the property `"true"`, but the handler
|
||||
// is still called with the boolean.
|
||||
assert.equal(shape, true);
|
||||
return 1;
|
||||
},
|
||||
};
|
||||
const matcher = getPrimitiveUnionMatcher<string | boolean>()(handlers);
|
||||
|
||||
// Act / Assert
|
||||
assert.equal(matcher(true), 1);
|
||||
assert.throws(() => matcher(false), /Unhandled shape: false/);
|
||||
});
|
||||
|
||||
// ============================================================================
|
||||
// Autocomplete — the language server is the oracle, not the type system
|
||||
// ============================================================================
|
||||
|
||||
// Completion is a contextual-type property that the type system cannot observe,
|
||||
// so the cases below read the popup from the repo's language server (via the
|
||||
// test helper) rather than pairing `expectTypeOf` with `assert` — see
|
||||
// development/testing.md § Autocomplete. They probe the *matcher's* overloads,
|
||||
// which is why they live with the matcher and not with the helper.
|
||||
const REPO_ROOT = path.resolve(import.meta.dirname, "..");
|
||||
const UNIVERSE = `"a" | "b" | "c"`;
|
||||
|
||||
// One session per probe: the tests share no language-server state (open
|
||||
// documents, project membership), so they pass in any order.
|
||||
interface LabelsProbe {
|
||||
readonly name: string;
|
||||
readonly factory: "getPrimitiveUnionMatcher" | "getPrimitiveUnionMatcherW";
|
||||
readonly body: string;
|
||||
readonly universe?: string;
|
||||
readonly tail?: string;
|
||||
}
|
||||
|
||||
const labelsFor = ({
|
||||
name,
|
||||
factory,
|
||||
body,
|
||||
universe = UNIVERSE,
|
||||
tail = "",
|
||||
}: LabelsProbe): Promise<readonly string[]> => {
|
||||
const session = new LspSession(REPO_ROOT);
|
||||
const target: CompletionTarget = {
|
||||
file: `src/__autocomplete_${name}.ts`,
|
||||
source: [
|
||||
`import { ${factory} } from "./index.ts";`,
|
||||
`const m = ${factory}<${universe}>()({`,
|
||||
body,
|
||||
`}${tail});`,
|
||||
"",
|
||||
].join("\n"),
|
||||
};
|
||||
return session
|
||||
.completionLabelsAt(target)
|
||||
.then((result) => result.labels)
|
||||
.finally(() => session.close());
|
||||
};
|
||||
|
||||
test("autocomplete: an exhaustive pattern requires the universe", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_fresh";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
body: " /*COMPLETE*/",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["a", "b", "c"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: handled keys drop out of the popup", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_after_key";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
body: " a: () => 1,\n /*COMPLETE*/",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["b", "c"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: a fallback makes the remaining keys optional", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_with_fallback";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
body: " /*COMPLETE*/",
|
||||
tail: ", () => 0",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["a?", "b?", "c?"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: with a fallback, handled keys stay optional", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_with_fallback_after_key";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
body: " a: () => 1,\n /*COMPLETE*/",
|
||||
tail: ", () => 0",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["b?", "c?"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: `getPrimitiveUnionMatcherW` offers the same popup as `getPrimitiveUnionMatcher`", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcherW_fresh";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcherW",
|
||||
body: " /*COMPLETE*/",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["a", "b", "c"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: `getPrimitiveUnionMatcherW` also offers optional keys with a fallback", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcherW_with_fallback";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcherW",
|
||||
body: " /*COMPLETE*/",
|
||||
tail: ", () => 0",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["a?", "b?", "c?"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: boolean and nullish keys are offered by name", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_boolean_nullish";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
universe: "boolean | null | undefined",
|
||||
body: " /*COMPLETE*/",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["false", "null", "true", "undefined"]);
|
||||
});
|
||||
});
|
||||
|
||||
test("autocomplete: a handled boolean literal drops out of the popup", () => {
|
||||
// Arrange
|
||||
const name = "getPrimitiveUnionMatcher_boolean_after_key";
|
||||
|
||||
// Act
|
||||
const labels = labelsFor({
|
||||
name,
|
||||
factory: "getPrimitiveUnionMatcher",
|
||||
universe: "boolean | null | undefined",
|
||||
body: " true: () => 1,\n /*COMPLETE*/",
|
||||
});
|
||||
|
||||
// Assert
|
||||
return labels.then((result) => {
|
||||
assert.deepEqual([...result], ["false", "null", "undefined"]);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user