🐛 Gate the universe to finite, literal keys
An open universe (`string`, `number`, a template literal) makes the handler map index-like, so a partial object satisfied the exhaustive overload and the runtime `dispatch` throw was reachable. A universe containing a member and its stringification (`"true" | true`, `1 | "1"`) collapsed two members onto one key. - reject broad universes and value/stringification collisions at the factory, with a diagnostic naming the reason - invert `PatternKey` against the universe (`Member<T, K>`) instead of `PatternParam<K>`, so a standalone `"true"` is typed `"true"` - intersect `UniverseGate<T>` into the handler and fallback parameters, preserving `R` inference and the popup
This commit is contained in:
tmu committed
1 parent
1723419e69
commit
3b5269f9e1
6 files changed
+953
-95
No files matched your search
+391
-32
@@ -495,26 +495,392 @@ test("getPrimitiveUnionMatcher factory rejects non-exhaustive boolean and nullis
|
||||
);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: an open universe keeps the fallback's remainder open", () => {
|
||||
test("getPrimitiveUnionMatcher: a standalone stringified literal is typed by the member, not its key", () => {
|
||||
// `"true"` is a string member whose `PatternKey` is `"true"`; inverting the
|
||||
// key must recover the string, not the boolean that also stringifies to it.
|
||||
// Arrange
|
||||
const factory = getPrimitiveUnionMatcher<string>();
|
||||
const factory = getPrimitiveUnionMatcher<"true" | "1">();
|
||||
|
||||
// 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;
|
||||
const matcher = factory({
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"true">();
|
||||
assert.equal(s, "true");
|
||||
return 1;
|
||||
},
|
||||
"1": (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"1">();
|
||||
assert.equal(s, "1");
|
||||
return 2;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: string) => number>();
|
||||
assert.equal(matcher("a"), 1);
|
||||
assert.equal(matcher("b"), 2);
|
||||
assert.equal(matcher("true"), 1);
|
||||
assert.equal(matcher("1"), 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: a broad universe is rejected", () => {
|
||||
// Act / Assert — the calls below must not compile
|
||||
// @ts-expect-error `string` is not a finite union of literals
|
||||
getPrimitiveUnionMatcher<string>()({ a: () => 1 });
|
||||
// @ts-expect-error `number` is not a finite union of literals
|
||||
getPrimitiveUnionMatcher<number>()({ 1: () => 1 });
|
||||
// @ts-expect-error a template literal is open
|
||||
getPrimitiveUnionMatcher<`a${string}`>()({ a: () => 1 });
|
||||
// @ts-expect-error `string | boolean` is open because of `string`
|
||||
getPrimitiveUnionMatcher<string | boolean>()({ true: () => 1 });
|
||||
// @ts-expect-error the widening factory rejects broad universes too
|
||||
getPrimitiveUnionMatcherW<string>()({ a: () => 1 });
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: a value/stringification collision is rejected", () => {
|
||||
// Act / Assert — the calls below must not compile
|
||||
// @ts-expect-error `true` collides with the string `"true"`
|
||||
getPrimitiveUnionMatcher<"true" | true>()({ true: () => 1 });
|
||||
// @ts-expect-error `false` collides with the string `"false"`
|
||||
getPrimitiveUnionMatcher<"false" | false>()({ false: () => 1 });
|
||||
// @ts-expect-error `null` collides with the string `"null"`
|
||||
getPrimitiveUnionMatcher<"null" | null>()({ null: () => 1 });
|
||||
// @ts-expect-error `undefined` collides with the string `"undefined"`
|
||||
getPrimitiveUnionMatcher<"undefined" | undefined>()({
|
||||
undefined: () => 1,
|
||||
});
|
||||
// @ts-expect-error the number `1` collides with the string `"1"`
|
||||
getPrimitiveUnionMatcher<1 | "1">()({ 1: () => 1 });
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: a collision is rejected beside legal members", () => {
|
||||
// Act / Assert — the calls below must not compile; the legal members do not
|
||||
// mask the collision. Each map is otherwise complete, so only the collision
|
||||
// can make it invalid.
|
||||
// @ts-expect-error `true` collides with `"true"` beside legal members
|
||||
getPrimitiveUnionMatcher<"true" | true | "a" | 2>()({
|
||||
true: () => 1,
|
||||
a: () => 2,
|
||||
2: () => 3,
|
||||
});
|
||||
// @ts-expect-error `false` collides with `"false"` beside legal members
|
||||
getPrimitiveUnionMatcher<"false" | false | "a" | 2>()({
|
||||
false: () => 1,
|
||||
a: () => 2,
|
||||
2: () => 3,
|
||||
});
|
||||
// @ts-expect-error `null` collides with `"null"` beside legal members
|
||||
getPrimitiveUnionMatcher<"null" | null | "a" | 2>()({
|
||||
null: () => 1,
|
||||
a: () => 2,
|
||||
2: () => 3,
|
||||
});
|
||||
// @ts-expect-error `undefined` collides with `"undefined"` beside legal members
|
||||
getPrimitiveUnionMatcher<"undefined" | undefined | "a" | 2>()({
|
||||
undefined: () => 1,
|
||||
a: () => 2,
|
||||
2: () => 3,
|
||||
});
|
||||
// @ts-expect-error `1` collides with `"1"` beside legal members
|
||||
getPrimitiveUnionMatcher<1 | "1" | "a" | true>()({
|
||||
1: () => 1,
|
||||
a: () => 2,
|
||||
true: () => 3,
|
||||
});
|
||||
});
|
||||
|
||||
test('getPrimitiveUnionMatcher: `"true"` and a bare `false` are legal together', () => {
|
||||
// Arrange — `false` stringifies to `"false"`, so it does not collide with
|
||||
// the string member `"true"`.
|
||||
const factory = getPrimitiveUnionMatcher<"true" | false | "a" | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"true">();
|
||||
assert.equal(s, "true");
|
||||
return 1;
|
||||
},
|
||||
false: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<false>();
|
||||
assert.equal(s, false);
|
||||
return 2;
|
||||
},
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 3;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 4;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert.equal(matcher("true"), 1);
|
||||
assert.equal(matcher(false), 2);
|
||||
assert.equal(matcher("a"), 3);
|
||||
assert.equal(matcher(2), 4);
|
||||
});
|
||||
|
||||
test('getPrimitiveUnionMatcher: `"false"` and a bare `true` are legal together', () => {
|
||||
// Arrange — `true` stringifies to `"true"`, not `"false"`.
|
||||
const factory = getPrimitiveUnionMatcher<"false" | true | "a" | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
false: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"false">();
|
||||
assert.equal(s, "false");
|
||||
return 1;
|
||||
},
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<true>();
|
||||
assert.equal(s, true);
|
||||
return 2;
|
||||
},
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 3;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 4;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert.equal(matcher("false"), 1);
|
||||
assert.equal(matcher(true), 2);
|
||||
assert.equal(matcher("a"), 3);
|
||||
assert.equal(matcher(2), 4);
|
||||
});
|
||||
|
||||
test('getPrimitiveUnionMatcher: `"null"` and a bare `undefined` are legal together', () => {
|
||||
// Arrange — `undefined` stringifies to `"undefined"`, not `"null"`.
|
||||
const factory = getPrimitiveUnionMatcher<"null" | undefined | "a" | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"null">();
|
||||
assert.equal(s, "null");
|
||||
return 1;
|
||||
},
|
||||
undefined: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<undefined>();
|
||||
assert.equal(s, undefined);
|
||||
return 2;
|
||||
},
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 3;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 4;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert.equal(matcher("null"), 1);
|
||||
assert.equal(matcher(undefined), 2);
|
||||
assert.equal(matcher("a"), 3);
|
||||
assert.equal(matcher(2), 4);
|
||||
});
|
||||
|
||||
test('getPrimitiveUnionMatcher: `"undefined"` and a bare `null` are legal together', () => {
|
||||
// Arrange — `null` stringifies to `"null"`, not `"undefined"`.
|
||||
const factory = getPrimitiveUnionMatcher<"undefined" | null | "a" | 2>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
undefined: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"undefined">();
|
||||
assert.equal(s, "undefined");
|
||||
return 1;
|
||||
},
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<null>();
|
||||
assert.equal(s, null);
|
||||
return 2;
|
||||
},
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 3;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 4;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert.equal(matcher("undefined"), 1);
|
||||
assert.equal(matcher(null), 2);
|
||||
assert.equal(matcher("a"), 3);
|
||||
assert.equal(matcher(2), 4);
|
||||
});
|
||||
|
||||
test('getPrimitiveUnionMatcher: `"1"` beside other numbers and strings is legal', () => {
|
||||
// Arrange — the task's example: `"1"` is the string member, `2` and `3`
|
||||
// are bare numbers, `"4"` is another string. No stringification lands on
|
||||
// another member.
|
||||
const factory = getPrimitiveUnionMatcher<"1" | 2 | 3 | "4">();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
"1": (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"1">();
|
||||
assert.equal(s, "1");
|
||||
return 1;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 2;
|
||||
},
|
||||
3: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<3>();
|
||||
assert.equal(s, 3);
|
||||
return 3;
|
||||
},
|
||||
"4": (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"4">();
|
||||
assert.equal(s, "4");
|
||||
return 4;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert.equal(matcher("1"), 1);
|
||||
assert.equal(matcher(2), 2);
|
||||
assert.equal(matcher(3), 3);
|
||||
assert.equal(matcher("4"), 4);
|
||||
});
|
||||
|
||||
// The maximum legal universe needs one handler per member; the statement count
|
||||
// is inherent to the case.
|
||||
// oxlint-disable-next-line max-statements
|
||||
test("getPrimitiveUnionMatcher: the maximum legal universe is supported", () => {
|
||||
// Arrange — every Matchable kind, one representation per value, plus extra
|
||||
// literals. No member's stringification is another member.
|
||||
type Legal =
|
||||
| "true"
|
||||
| false
|
||||
| null
|
||||
| undefined
|
||||
| "1"
|
||||
| 2
|
||||
| 3
|
||||
| "a"
|
||||
| "b"
|
||||
| "4";
|
||||
const factory = getPrimitiveUnionMatcher<Legal>();
|
||||
|
||||
// Act
|
||||
const matcher = factory({
|
||||
true: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"true">();
|
||||
assert.equal(s, "true");
|
||||
return 1;
|
||||
},
|
||||
false: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<false>();
|
||||
assert.equal(s, false);
|
||||
return 2;
|
||||
},
|
||||
null: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<null>();
|
||||
assert.equal(s, null);
|
||||
return 3;
|
||||
},
|
||||
undefined: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<undefined>();
|
||||
assert.equal(s, undefined);
|
||||
return 4;
|
||||
},
|
||||
"1": (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"1">();
|
||||
assert.equal(s, "1");
|
||||
return 5;
|
||||
},
|
||||
2: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<2>();
|
||||
assert.equal(s, 2);
|
||||
return 6;
|
||||
},
|
||||
3: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<3>();
|
||||
assert.equal(s, 3);
|
||||
return 7;
|
||||
},
|
||||
a: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"a">();
|
||||
assert.equal(s, "a");
|
||||
return 8;
|
||||
},
|
||||
b: (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"b">();
|
||||
assert.equal(s, "b");
|
||||
return 9;
|
||||
},
|
||||
"4": (s) => {
|
||||
expectTypeOf(s).toEqualTypeOf<"4">();
|
||||
assert.equal(s, "4");
|
||||
return 10;
|
||||
},
|
||||
});
|
||||
|
||||
// Assert
|
||||
expectTypeOf(matcher).toEqualTypeOf<(shape: Legal) => number>();
|
||||
assert.equal(matcher("true"), 1);
|
||||
assert.equal(matcher(false), 2);
|
||||
assert.equal(matcher(null), 3);
|
||||
assert.equal(matcher(undefined), 4);
|
||||
assert.equal(matcher("1"), 5);
|
||||
assert.equal(matcher(2), 6);
|
||||
assert.equal(matcher(3), 7);
|
||||
assert.equal(matcher("a"), 8);
|
||||
assert.equal(matcher("b"), 9);
|
||||
assert.equal(matcher("4"), 10);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: the maximum illegal universe is rejected", () => {
|
||||
// Arrange — every value paired with its stringification.
|
||||
type Illegal =
|
||||
| "true"
|
||||
| true
|
||||
| "false"
|
||||
| false
|
||||
| "null"
|
||||
| null
|
||||
| "undefined"
|
||||
| undefined
|
||||
| "1"
|
||||
| 1;
|
||||
|
||||
// Act / Assert — the call below must not compile
|
||||
// @ts-expect-error every value collides with its stringification
|
||||
getPrimitiveUnionMatcher<Illegal>()({
|
||||
true: () => 1,
|
||||
false: () => 2,
|
||||
null: () => 3,
|
||||
undefined: () => 4,
|
||||
"1": () => 5,
|
||||
});
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcher: an open universe is rejected with a fallback too", () => {
|
||||
// Act / Assert — the call below must not compile; a broad universe is
|
||||
// unsupported whether or not a fallback is supplied.
|
||||
// @ts-expect-error `string` is not a finite union of literals
|
||||
getPrimitiveUnionMatcher<string>()({ a: () => 1 }, () => 2);
|
||||
});
|
||||
|
||||
test("getPrimitiveUnionMatcherW factory rejects patterns outside its contract", () => {
|
||||
@@ -539,16 +905,11 @@ test("getPrimitiveUnionMatcherW factory rejects patterns outside its contract",
|
||||
// ============================================================================
|
||||
|
||||
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);
|
||||
// Arrange — a finite universe is exhaustive through the typed API, so the
|
||||
// defensive throw is reachable only by widening the factory and dropping a
|
||||
// handler.
|
||||
const bypass: Function = getPrimitiveUnionMatcher<"a" | "b">();
|
||||
const matcher: (shape: "a" | "b") => number = bypass({ a: () => 1 });
|
||||
|
||||
// Act / Assert
|
||||
assert.equal(matcher("a"), 1);
|
||||
@@ -556,17 +917,15 @@ test("getPrimitiveUnionMatcher: an unhandled shape throws without a fallback", (
|
||||
});
|
||||
|
||||
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.
|
||||
// Arrange — as above; `true` indexes the map as the property `"true"`, but
|
||||
// the handler is still called with the boolean.
|
||||
const bypass: Function = getPrimitiveUnionMatcher<true | false>();
|
||||
const matcher: (shape: boolean) => number = bypass({
|
||||
true: (shape: boolean) => {
|
||||
assert.equal(shape, true);
|
||||
return 1;
|
||||
},
|
||||
};
|
||||
const matcher = getPrimitiveUnionMatcher<string | boolean>()(handlers);
|
||||
});
|
||||
|
||||
// Act / Assert
|
||||
assert.equal(matcher(true), 1);
|
||||
|
||||
Reference in new issue
Block a user