microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-05 16:38:05 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Added tests

Browse Source
This commit is contained in:
Ron Buckton 2017-09-08 17:10:01 -07:00
parent 06e46fbde6
commit a4d2b25859
14 changed files with 2601 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/compiler/checker.ts
View File

@ -7789,9 +7789,9 @@ namespace ts {
return getUnionType(constituents);
}
function getMatchType(typeArgument: Type, clauses: ReadonlyArray<MatchTypeClause>, elseType: Type | undefined, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]) {
if (clauses.length > 0 && (isGenericObjectType(typeArgument) || forEach(clauses, isGenericMatchTypeClause))) {
if (clauses.length > 0) {
function getMatchType(typeArgument: Type, clauses: ReadonlyArray<MatchTypeClause>, elseType: Type | undefined, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
if (clauses.length > 0) {
if (isGenericObjectType(typeArgument) || forEach(clauses, isGenericMatchTypeClause)) {
const type = <MatchType>createType(TypeFlags.Match);
type.typeArgument = typeArgument;
type.clauses = clauses;
@ -7800,14 +7800,19 @@ namespace ts {
type.aliasTypeArguments = aliasTypeArguments;
return type;
}
}
for (const clause of clauses) {
if (isTypeAssignableTo(typeArgument, clause.matchType)) {
return clause.resultType;
// distribute `match` across unions
if (typeArgument.flags & TypeFlags.Union) {
const types = map((<UnionType>typeArgument).types, constituent => getMatchType(constituent, clauses, elseType));
return getUnionType(types, /*subtypeReduction*/ false);
}
for (const clause of clauses) {
if (isTypeAssignableTo(typeArgument, clause.matchType)) {
return clause.resultType;
}
}
}
return elseType || neverType;
}

1
src/compiler/emitter.ts
View File

@ -1125,6 +1125,7 @@ namespace ts {
function emitMatchType(node: MatchTypeNode) {
emit(node.typeArgument);
write(" ");
writeToken(SyntaxKind.MatchKeyword, node.typeArgument.end);
write(" ");
emit(node.matchBlock);

281
tests/baselines/reference/matchGenericTypeArgument.js Normal file
View File

@ -0,0 +1,281 @@
//// [matchGenericTypeArgument.ts]
// all of these test `match` with generics.
// empty
type A<T> = T match {
};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
// only else
type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
// only one exact match, no else
type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
// only one subtype match, no else
type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
// multiple possible subtype matches, no else
type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
// multiple possible matches (subtype first), no else
type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
// never
type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
// undefined
type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;
// union, both match, no else
type I<T, U> = (T | U) match {
1: "1",
2: "2"
};
declare const I11: I<1, 1>;
declare const I12: I<1, 2>;
declare const I11or2: I<1, 1 | 2>;
declare const I1string: I<1, "">;
declare const I1empty: I<1, {}>;
declare const I1never: I<1, never>;
declare const I1any: I<1, any>;
declare const I1undefined: I<1, undefined>;
// union, one match, no else
type J<T, U> = (T | U) match {
1: "1"
};
declare const J11: J<1, 1>;
declare const J12: J<1, 2>;
declare const J22: J<2, 2>;
declare const J11or2: J<1, 1 | 2>;
declare const J1string: J<1, "">;
declare const J1empty: J<1, {}>;
declare const J1never: J<1, never>;
declare const J1any: J<1, any>;
declare const J1undefined: J<1, undefined>;
// union, one match, else
type K<T, U> = (T | U) match {
1: "1",
else: "else"
};
declare const K11: K<1, 1>;
declare const K12: K<1, 2>;
declare const K22: K<2, 2>;
declare const K11or2: K<1, 1 | 2>;
declare const K1string: K<1, "">;
declare const K1empty: K<1, {}>;
declare const K1never: K<1, never>;
declare const K1any: K<1, any>;
declare const K1undefined: K<1, undefined>;
//// [matchGenericTypeArgument.js]
// all of these test `match` with generics.
//// [matchGenericTypeArgument.d.ts]
declare type A<T> = T match {};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
declare type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
declare type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
declare type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
declare type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
declare type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
declare type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
declare type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;
declare type I<T, U> = (T | U) match {
1: "1",
2: "2"
};
declare const I11: I<1, 1>;
declare const I12: I<1, 2>;
declare const I11or2: I<1, 1 | 2>;
declare const I1string: I<1, "">;
declare const I1empty: I<1, {}>;
declare const I1never: I<1, never>;
declare const I1any: I<1, any>;
declare const I1undefined: I<1, undefined>;
declare type J<T, U> = (T | U) match {
1: "1"
};
declare const J11: J<1, 1>;
declare const J12: J<1, 2>;
declare const J22: J<2, 2>;
declare const J11or2: J<1, 1 | 2>;
declare const J1string: J<1, "">;
declare const J1empty: J<1, {}>;
declare const J1never: J<1, never>;
declare const J1any: J<1, any>;
declare const J1undefined: J<1, undefined>;
declare type K<T, U> = (T | U) match {
1: "1",
else: "else"
};
declare const K11: K<1, 1>;
declare const K12: K<1, 2>;
declare const K22: K<2, 2>;
declare const K11or2: K<1, 1 | 2>;
declare const K1string: K<1, "">;
declare const K1empty: K<1, {}>;
declare const K1never: K<1, never>;
declare const K1any: K<1, any>;
declare const K1undefined: K<1, undefined>;

445
tests/baselines/reference/matchGenericTypeArgument.symbols Normal file
View File

@ -0,0 +1,445 @@
=== tests/cases/conformance/types/match/matchGenericTypeArgument.ts ===
// all of these test `match` with generics.
// empty
type A<T> = T match {
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 3, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 3, 7))
};
declare const A1: A<1>;
>A1 : Symbol(A1, Decl(matchGenericTypeArgument.ts, 5, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const A1or2: A<1 | 2>;
>A1or2 : Symbol(A1or2, Decl(matchGenericTypeArgument.ts, 6, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const Astring: A<"">;
>Astring : Symbol(Astring, Decl(matchGenericTypeArgument.ts, 7, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const Aempty: A<{}>;
>Aempty : Symbol(Aempty, Decl(matchGenericTypeArgument.ts, 8, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const Anever: A<never>;
>Anever : Symbol(Anever, Decl(matchGenericTypeArgument.ts, 9, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const Aany: A<any>;
>Aany : Symbol(Aany, Decl(matchGenericTypeArgument.ts, 10, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
declare const Aundefined: A<undefined>;
>Aundefined : Symbol(Aundefined, Decl(matchGenericTypeArgument.ts, 11, 13))
>A : Symbol(A, Decl(matchGenericTypeArgument.ts, 0, 0))
// only else
type B<T> = T match {
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 14, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 14, 7))
else: "else"
};
declare const B1: B<1>;
>B1 : Symbol(B1, Decl(matchGenericTypeArgument.ts, 17, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const B1or2: B<1 | 2>;
>B1or2 : Symbol(B1or2, Decl(matchGenericTypeArgument.ts, 18, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const Bstring: B<"">;
>Bstring : Symbol(Bstring, Decl(matchGenericTypeArgument.ts, 19, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const Bempty: B<{}>;
>Bempty : Symbol(Bempty, Decl(matchGenericTypeArgument.ts, 20, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const Bnever: B<never>;
>Bnever : Symbol(Bnever, Decl(matchGenericTypeArgument.ts, 21, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const Bany: B<any>;
>Bany : Symbol(Bany, Decl(matchGenericTypeArgument.ts, 22, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
declare const Bundefined: B<undefined>;
>Bundefined : Symbol(Bundefined, Decl(matchGenericTypeArgument.ts, 23, 13))
>B : Symbol(B, Decl(matchGenericTypeArgument.ts, 11, 39))
// only one exact match, no else
type C<T> = T match {
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 26, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 26, 7))
1: "1"
};
declare const C1: C<1>;
>C1 : Symbol(C1, Decl(matchGenericTypeArgument.ts, 29, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const C1or2: C<1 | 2>;
>C1or2 : Symbol(C1or2, Decl(matchGenericTypeArgument.ts, 30, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const Cstring: C<"">;
>Cstring : Symbol(Cstring, Decl(matchGenericTypeArgument.ts, 31, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const Cempty: C<{}>;
>Cempty : Symbol(Cempty, Decl(matchGenericTypeArgument.ts, 32, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const Cnever: C<never>;
>Cnever : Symbol(Cnever, Decl(matchGenericTypeArgument.ts, 33, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const Cany: C<any>;
>Cany : Symbol(Cany, Decl(matchGenericTypeArgument.ts, 34, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
declare const Cundefined: C<undefined>;
>Cundefined : Symbol(Cundefined, Decl(matchGenericTypeArgument.ts, 35, 13))
>C : Symbol(C, Decl(matchGenericTypeArgument.ts, 23, 39))
// only one subtype match, no else
type D<T> = T match {
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 38, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 38, 7))
number: "number"
};
declare const D1: D<1>;
>D1 : Symbol(D1, Decl(matchGenericTypeArgument.ts, 41, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const D1or2: D<1 | 2>;
>D1or2 : Symbol(D1or2, Decl(matchGenericTypeArgument.ts, 42, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const Dstring: D<"">;
>Dstring : Symbol(Dstring, Decl(matchGenericTypeArgument.ts, 43, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const Dempty: D<{}>;
>Dempty : Symbol(Dempty, Decl(matchGenericTypeArgument.ts, 44, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const Dnever: D<never>;
>Dnever : Symbol(Dnever, Decl(matchGenericTypeArgument.ts, 45, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const Dany: D<any>;
>Dany : Symbol(Dany, Decl(matchGenericTypeArgument.ts, 46, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
declare const Dundefined: D<undefined>;
>Dundefined : Symbol(Dundefined, Decl(matchGenericTypeArgument.ts, 47, 13))
>D : Symbol(D, Decl(matchGenericTypeArgument.ts, 35, 39))
// multiple possible subtype matches, no else
type E<T> = T match {
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 50, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 50, 7))
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
>E1 : Symbol(E1, Decl(matchGenericTypeArgument.ts, 54, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const E1or2: E<1 | 2>;
>E1or2 : Symbol(E1or2, Decl(matchGenericTypeArgument.ts, 55, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const E3: E<3>;
>E3 : Symbol(E3, Decl(matchGenericTypeArgument.ts, 56, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const Estring: E<"">;
>Estring : Symbol(Estring, Decl(matchGenericTypeArgument.ts, 57, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const Eempty: E<{}>;
>Eempty : Symbol(Eempty, Decl(matchGenericTypeArgument.ts, 58, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const Enever: E<never>;
>Enever : Symbol(Enever, Decl(matchGenericTypeArgument.ts, 59, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const Eany: E<any>;
>Eany : Symbol(Eany, Decl(matchGenericTypeArgument.ts, 60, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
declare const Eundefined: E<undefined>;
>Eundefined : Symbol(Eundefined, Decl(matchGenericTypeArgument.ts, 61, 13))
>E : Symbol(E, Decl(matchGenericTypeArgument.ts, 47, 39))
// multiple possible matches (subtype first), no else
type F<T> = T match {
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 64, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 64, 7))
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
>F1 : Symbol(F1, Decl(matchGenericTypeArgument.ts, 69, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const F1or2: F<1 | 2>;
>F1or2 : Symbol(F1or2, Decl(matchGenericTypeArgument.ts, 70, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const F2or3: F<2 | 3>;
>F2or3 : Symbol(F2or3, Decl(matchGenericTypeArgument.ts, 71, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const F3: F<3>;
>F3 : Symbol(F3, Decl(matchGenericTypeArgument.ts, 72, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const Fstring: F<"">;
>Fstring : Symbol(Fstring, Decl(matchGenericTypeArgument.ts, 73, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const Fempty: F<{}>;
>Fempty : Symbol(Fempty, Decl(matchGenericTypeArgument.ts, 74, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const Fnever: F<never>;
>Fnever : Symbol(Fnever, Decl(matchGenericTypeArgument.ts, 75, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const Fany: F<any>;
>Fany : Symbol(Fany, Decl(matchGenericTypeArgument.ts, 76, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
declare const Fundefined: F<undefined>;
>Fundefined : Symbol(Fundefined, Decl(matchGenericTypeArgument.ts, 77, 13))
>F : Symbol(F, Decl(matchGenericTypeArgument.ts, 61, 39))
// never
type G<T> = T match {
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 80, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 80, 7))
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
>G1 : Symbol(G1, Decl(matchGenericTypeArgument.ts, 85, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const G1or2: G<1 | 2>;
>G1or2 : Symbol(G1or2, Decl(matchGenericTypeArgument.ts, 86, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const Gstring: G<"">;
>Gstring : Symbol(Gstring, Decl(matchGenericTypeArgument.ts, 87, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const Gempty: G<{}>;
>Gempty : Symbol(Gempty, Decl(matchGenericTypeArgument.ts, 88, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const Gnever: G<never>;
>Gnever : Symbol(Gnever, Decl(matchGenericTypeArgument.ts, 89, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const Gany: G<any>;
>Gany : Symbol(Gany, Decl(matchGenericTypeArgument.ts, 90, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
declare const Gundefined: G<undefined>;
>Gundefined : Symbol(Gundefined, Decl(matchGenericTypeArgument.ts, 91, 13))
>G : Symbol(G, Decl(matchGenericTypeArgument.ts, 77, 39))
// undefined
type H<T> = T match {
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 94, 7))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 94, 7))
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
>H1 : Symbol(H1, Decl(matchGenericTypeArgument.ts, 99, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const H1or2: H<1 | 2>;
>H1or2 : Symbol(H1or2, Decl(matchGenericTypeArgument.ts, 100, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const Hstring: H<"">;
>Hstring : Symbol(Hstring, Decl(matchGenericTypeArgument.ts, 101, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const Hempty: H<{}>;
>Hempty : Symbol(Hempty, Decl(matchGenericTypeArgument.ts, 102, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const Hnever: H<never>;
>Hnever : Symbol(Hnever, Decl(matchGenericTypeArgument.ts, 103, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const Hany: H<any>;
>Hany : Symbol(Hany, Decl(matchGenericTypeArgument.ts, 104, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
declare const Hundefined: H<undefined>;
>Hundefined : Symbol(Hundefined, Decl(matchGenericTypeArgument.ts, 105, 13))
>H : Symbol(H, Decl(matchGenericTypeArgument.ts, 91, 39))
// union, both match, no else
type I<T, U> = (T | U) match {
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 108, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 108, 9))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 108, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 108, 9))
1: "1",
2: "2"
};
declare const I11: I<1, 1>;
>I11 : Symbol(I11, Decl(matchGenericTypeArgument.ts, 112, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I12: I<1, 2>;
>I12 : Symbol(I12, Decl(matchGenericTypeArgument.ts, 113, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I11or2: I<1, 1 | 2>;
>I11or2 : Symbol(I11or2, Decl(matchGenericTypeArgument.ts, 114, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I1string: I<1, "">;
>I1string : Symbol(I1string, Decl(matchGenericTypeArgument.ts, 115, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I1empty: I<1, {}>;
>I1empty : Symbol(I1empty, Decl(matchGenericTypeArgument.ts, 116, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I1never: I<1, never>;
>I1never : Symbol(I1never, Decl(matchGenericTypeArgument.ts, 117, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I1any: I<1, any>;
>I1any : Symbol(I1any, Decl(matchGenericTypeArgument.ts, 118, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
declare const I1undefined: I<1, undefined>;
>I1undefined : Symbol(I1undefined, Decl(matchGenericTypeArgument.ts, 119, 13))
>I : Symbol(I, Decl(matchGenericTypeArgument.ts, 105, 39))
// union, one match, no else
type J<T, U> = (T | U) match {
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 122, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 122, 9))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 122, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 122, 9))
1: "1"
};
declare const J11: J<1, 1>;
>J11 : Symbol(J11, Decl(matchGenericTypeArgument.ts, 125, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J12: J<1, 2>;
>J12 : Symbol(J12, Decl(matchGenericTypeArgument.ts, 126, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J22: J<2, 2>;
>J22 : Symbol(J22, Decl(matchGenericTypeArgument.ts, 127, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J11or2: J<1, 1 | 2>;
>J11or2 : Symbol(J11or2, Decl(matchGenericTypeArgument.ts, 128, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J1string: J<1, "">;
>J1string : Symbol(J1string, Decl(matchGenericTypeArgument.ts, 129, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J1empty: J<1, {}>;
>J1empty : Symbol(J1empty, Decl(matchGenericTypeArgument.ts, 130, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J1never: J<1, never>;
>J1never : Symbol(J1never, Decl(matchGenericTypeArgument.ts, 131, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J1any: J<1, any>;
>J1any : Symbol(J1any, Decl(matchGenericTypeArgument.ts, 132, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
declare const J1undefined: J<1, undefined>;
>J1undefined : Symbol(J1undefined, Decl(matchGenericTypeArgument.ts, 133, 13))
>J : Symbol(J, Decl(matchGenericTypeArgument.ts, 119, 43))
// union, one match, else
type K<T, U> = (T | U) match {
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 136, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 136, 9))
>T : Symbol(T, Decl(matchGenericTypeArgument.ts, 136, 7))
>U : Symbol(U, Decl(matchGenericTypeArgument.ts, 136, 9))
1: "1",
else: "else"
};
declare const K11: K<1, 1>;
>K11 : Symbol(K11, Decl(matchGenericTypeArgument.ts, 140, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K12: K<1, 2>;
>K12 : Symbol(K12, Decl(matchGenericTypeArgument.ts, 141, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K22: K<2, 2>;
>K22 : Symbol(K22, Decl(matchGenericTypeArgument.ts, 142, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K11or2: K<1, 1 | 2>;
>K11or2 : Symbol(K11or2, Decl(matchGenericTypeArgument.ts, 143, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K1string: K<1, "">;
>K1string : Symbol(K1string, Decl(matchGenericTypeArgument.ts, 144, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K1empty: K<1, {}>;
>K1empty : Symbol(K1empty, Decl(matchGenericTypeArgument.ts, 145, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K1never: K<1, never>;
>K1never : Symbol(K1never, Decl(matchGenericTypeArgument.ts, 146, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K1any: K<1, any>;
>K1any : Symbol(K1any, Decl(matchGenericTypeArgument.ts, 147, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))
declare const K1undefined: K<1, undefined>;
>K1undefined : Symbol(K1undefined, Decl(matchGenericTypeArgument.ts, 148, 13))
>K : Symbol(K, Decl(matchGenericTypeArgument.ts, 133, 43))

445
tests/baselines/reference/matchGenericTypeArgument.types Normal file
View File

@ -0,0 +1,445 @@
=== tests/cases/conformance/types/match/matchGenericTypeArgument.ts ===
// all of these test `match` with generics.
// empty
type A<T> = T match {
>A : never
>T : T
>T : T
};
declare const A1: A<1>;
>A1 : never
>A : never
declare const A1or2: A<1 | 2>;
>A1or2 : never
>A : never
declare const Astring: A<"">;
>Astring : never
>A : never
declare const Aempty: A<{}>;
>Aempty : never
>A : never
declare const Anever: A<never>;
>Anever : never
>A : never
declare const Aany: A<any>;
>Aany : never
>A : never
declare const Aundefined: A<undefined>;
>Aundefined : never
>A : never
// only else
type B<T> = T match {
>B : "else"
>T : T
>T : T
else: "else"
};
declare const B1: B<1>;
>B1 : "else"
>B : "else"
declare const B1or2: B<1 | 2>;
>B1or2 : "else"
>B : "else"
declare const Bstring: B<"">;
>Bstring : "else"
>B : "else"
declare const Bempty: B<{}>;
>Bempty : "else"
>B : "else"
declare const Bnever: B<never>;
>Bnever : "else"
>B : "else"
declare const Bany: B<any>;
>Bany : "else"
>B : "else"
declare const Bundefined: B<undefined>;
>Bundefined : "else"
>B : "else"
// only one exact match, no else
type C<T> = T match {
>C : C<T>
>T : T
>T : T
1: "1"
};
declare const C1: C<1>;
>C1 : "1"
>C : C<T>
declare const C1or2: C<1 | 2>;
>C1or2 : "1"
>C : C<T>
declare const Cstring: C<"">;
>Cstring : never
>C : C<T>
declare const Cempty: C<{}>;
>Cempty : never
>C : C<T>
declare const Cnever: C<never>;
>Cnever : "1"
>C : C<T>
declare const Cany: C<any>;
>Cany : "1"
>C : C<T>
declare const Cundefined: C<undefined>;
>Cundefined : "1"
>C : C<T>
// only one subtype match, no else
type D<T> = T match {
>D : D<T>
>T : T
>T : T
number: "number"
};
declare const D1: D<1>;
>D1 : "number"
>D : D<T>
declare const D1or2: D<1 | 2>;
>D1or2 : "number"
>D : D<T>
declare const Dstring: D<"">;
>Dstring : never
>D : D<T>
declare const Dempty: D<{}>;
>Dempty : never
>D : D<T>
declare const Dnever: D<never>;
>Dnever : "number"
>D : D<T>
declare const Dany: D<any>;
>Dany : "number"
>D : D<T>
declare const Dundefined: D<undefined>;
>Dundefined : "number"
>D : D<T>
// multiple possible subtype matches, no else
type E<T> = T match {
>E : E<T>
>T : T
>T : T
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
>E1 : "1 | 2"
>E : E<T>
declare const E1or2: E<1 | 2>;
>E1or2 : "1 | 2"
>E : E<T>
declare const E3: E<3>;
>E3 : "number"
>E : E<T>
declare const Estring: E<"">;
>Estring : never
>E : E<T>
declare const Eempty: E<{}>;
>Eempty : never
>E : E<T>
declare const Enever: E<never>;
>Enever : "1 | 2"
>E : E<T>
declare const Eany: E<any>;
>Eany : "1 | 2"
>E : E<T>
declare const Eundefined: E<undefined>;
>Eundefined : "1 | 2"
>E : E<T>
// multiple possible matches (subtype first), no else
type F<T> = T match {
>F : F<T>
>T : T
>T : T
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
>F1 : "1 | 2"
>F : F<T>
declare const F1or2: F<1 | 2>;
>F1or2 : "1 | 2"
>F : F<T>
declare const F2or3: F<2 | 3>;
>F2or3 : "number" | "1 | 2"
>F : F<T>
declare const F3: F<3>;
>F3 : "number"
>F : F<T>
declare const Fstring: F<"">;
>Fstring : never
>F : F<T>
declare const Fempty: F<{}>;
>Fempty : never
>F : F<T>
declare const Fnever: F<never>;
>Fnever : "1 | 2"
>F : F<T>
declare const Fany: F<any>;
>Fany : "1 | 2"
>F : F<T>
declare const Fundefined: F<undefined>;
>Fundefined : "1 | 2"
>F : F<T>
// never
type G<T> = T match {
>G : G<T>
>T : T
>T : T
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
>G1 : "number"
>G : G<T>
declare const G1or2: G<1 | 2>;
>G1or2 : "number"
>G : G<T>
declare const Gstring: G<"">;
>Gstring : "else"
>G : G<T>
declare const Gempty: G<{}>;
>Gempty : "else"
>G : G<T>
declare const Gnever: G<never>;
>Gnever : "never"
>G : G<T>
declare const Gany: G<any>;
>Gany : "number"
>G : G<T>
declare const Gundefined: G<undefined>;
>Gundefined : "number"
>G : G<T>
// undefined
type H<T> = T match {
>H : H<T>
>T : T
>T : T
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
>H1 : "number"
>H : H<T>
declare const H1or2: H<1 | 2>;
>H1or2 : "number"
>H : H<T>
declare const Hstring: H<"">;
>Hstring : "else"
>H : H<T>
declare const Hempty: H<{}>;
>Hempty : "else"
>H : H<T>
declare const Hnever: H<never>;
>Hnever : "undefined"
>H : H<T>
declare const Hany: H<any>;
>Hany : "undefined"
>H : H<T>
declare const Hundefined: H<undefined>;
>Hundefined : "undefined"
>H : H<T>
// union, both match, no else
type I<T, U> = (T | U) match {
>I : I<T, U>
>T : T
>U : U
>T : T
>U : U
1: "1",
2: "2"
};
declare const I11: I<1, 1>;
>I11 : "1"
>I : I<T, U>
declare const I12: I<1, 2>;
>I12 : "1" | "2"
>I : I<T, U>
declare const I11or2: I<1, 1 | 2>;
>I11or2 : "1" | "2"
>I : I<T, U>
declare const I1string: I<1, "">;
>I1string : "1"
>I : I<T, U>
declare const I1empty: I<1, {}>;
>I1empty : "1"
>I : I<T, U>
declare const I1never: I<1, never>;
>I1never : "1"
>I : I<T, U>
declare const I1any: I<1, any>;
>I1any : "1"
>I : I<T, U>
declare const I1undefined: I<1, undefined>;
>I1undefined : "1"
>I : I<T, U>
// union, one match, no else
type J<T, U> = (T | U) match {
>J : J<T, U>
>T : T
>U : U
>T : T
>U : U
1: "1"
};
declare const J11: J<1, 1>;
>J11 : "1"
>J : J<T, U>
declare const J12: J<1, 2>;
>J12 : "1"
>J : J<T, U>
declare const J22: J<2, 2>;
>J22 : never
>J : J<T, U>
declare const J11or2: J<1, 1 | 2>;
>J11or2 : "1"
>J : J<T, U>
declare const J1string: J<1, "">;
>J1string : "1"
>J : J<T, U>
declare const J1empty: J<1, {}>;
>J1empty : "1"
>J : J<T, U>
declare const J1never: J<1, never>;
>J1never : "1"
>J : J<T, U>
declare const J1any: J<1, any>;
>J1any : "1"
>J : J<T, U>
declare const J1undefined: J<1, undefined>;
>J1undefined : "1"
>J : J<T, U>
// union, one match, else
type K<T, U> = (T | U) match {
>K : K<T, U>
>T : T
>U : U
>T : T
>U : U
1: "1",
else: "else"
};
declare const K11: K<1, 1>;
>K11 : "1"
>K : K<T, U>
declare const K12: K<1, 2>;
>K12 : "else" | "1"
>K : K<T, U>
declare const K22: K<2, 2>;
>K22 : "else"
>K : K<T, U>
declare const K11or2: K<1, 1 | 2>;
>K11or2 : "else" | "1"
>K : K<T, U>
declare const K1string: K<1, "">;
>K1string : "else" | "1"
>K : K<T, U>
declare const K1empty: K<1, {}>;
>K1empty : "else" | "1"
>K : K<T, U>
declare const K1never: K<1, never>;
>K1never : "1"
>K : K<T, U>
declare const K1any: K<1, any>;
>K1any : "1"
>K : K<T, U>
declare const K1undefined: K<1, undefined>;
>K1undefined : "1"
>K : K<T, U>

202
tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.js Normal file
View File

@ -0,0 +1,202 @@
//// [matchGenericTypeArgumentStrictNullChecks.ts]
// all of these test `match` with generics and --strictNullChecks.
// empty
type A<T> = T match {
};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
// only else
type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
// only one exact match, no else
type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
// only one subtype match, no else
type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
// multiple possible subtype matches, no else
type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
// multiple possible matches (subtype first), no else
type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
// never
type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
// undefined
type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;
//// [matchGenericTypeArgumentStrictNullChecks.js]
// all of these test `match` with generics and --strictNullChecks.
//// [matchGenericTypeArgumentStrictNullChecks.d.ts]
declare type A<T> = T match {};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
declare type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
declare type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
declare type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
declare type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
declare type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
declare type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
declare type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;

309
tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.symbols Normal file
View File

@ -0,0 +1,309 @@
=== tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts ===
// all of these test `match` with generics and --strictNullChecks.
// empty
type A<T> = T match {
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 3, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 3, 7))
};
declare const A1: A<1>;
>A1 : Symbol(A1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 5, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const A1or2: A<1 | 2>;
>A1or2 : Symbol(A1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 6, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const Astring: A<"">;
>Astring : Symbol(Astring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 7, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const Aempty: A<{}>;
>Aempty : Symbol(Aempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 8, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const Anever: A<never>;
>Anever : Symbol(Anever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 9, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const Aany: A<any>;
>Aany : Symbol(Aany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 10, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
declare const Aundefined: A<undefined>;
>Aundefined : Symbol(Aundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 13))
>A : Symbol(A, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 0, 0))
// only else
type B<T> = T match {
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 14, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 14, 7))
else: "else"
};
declare const B1: B<1>;
>B1 : Symbol(B1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 17, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const B1or2: B<1 | 2>;
>B1or2 : Symbol(B1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 18, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const Bstring: B<"">;
>Bstring : Symbol(Bstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 19, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const Bempty: B<{}>;
>Bempty : Symbol(Bempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 20, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const Bnever: B<never>;
>Bnever : Symbol(Bnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 21, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const Bany: B<any>;
>Bany : Symbol(Bany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 22, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
declare const Bundefined: B<undefined>;
>Bundefined : Symbol(Bundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 13))
>B : Symbol(B, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 11, 39))
// only one exact match, no else
type C<T> = T match {
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 26, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 26, 7))
1: "1"
};
declare const C1: C<1>;
>C1 : Symbol(C1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 29, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const C1or2: C<1 | 2>;
>C1or2 : Symbol(C1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 30, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const Cstring: C<"">;
>Cstring : Symbol(Cstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 31, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const Cempty: C<{}>;
>Cempty : Symbol(Cempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 32, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const Cnever: C<never>;
>Cnever : Symbol(Cnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 33, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const Cany: C<any>;
>Cany : Symbol(Cany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 34, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
declare const Cundefined: C<undefined>;
>Cundefined : Symbol(Cundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 13))
>C : Symbol(C, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 23, 39))
// only one subtype match, no else
type D<T> = T match {
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 38, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 38, 7))
number: "number"
};
declare const D1: D<1>;
>D1 : Symbol(D1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 41, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const D1or2: D<1 | 2>;
>D1or2 : Symbol(D1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 42, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const Dstring: D<"">;
>Dstring : Symbol(Dstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 43, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const Dempty: D<{}>;
>Dempty : Symbol(Dempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 44, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const Dnever: D<never>;
>Dnever : Symbol(Dnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 45, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const Dany: D<any>;
>Dany : Symbol(Dany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 46, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
declare const Dundefined: D<undefined>;
>Dundefined : Symbol(Dundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 13))
>D : Symbol(D, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 35, 39))
// multiple possible subtype matches, no else
type E<T> = T match {
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 50, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 50, 7))
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
>E1 : Symbol(E1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 54, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const E1or2: E<1 | 2>;
>E1or2 : Symbol(E1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 55, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const E3: E<3>;
>E3 : Symbol(E3, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 56, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const Estring: E<"">;
>Estring : Symbol(Estring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 57, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const Eempty: E<{}>;
>Eempty : Symbol(Eempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 58, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const Enever: E<never>;
>Enever : Symbol(Enever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 59, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const Eany: E<any>;
>Eany : Symbol(Eany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 60, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
declare const Eundefined: E<undefined>;
>Eundefined : Symbol(Eundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 13))
>E : Symbol(E, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 47, 39))
// multiple possible matches (subtype first), no else
type F<T> = T match {
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 64, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 64, 7))
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
>F1 : Symbol(F1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 69, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const F1or2: F<1 | 2>;
>F1or2 : Symbol(F1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 70, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const F2or3: F<2 | 3>;
>F2or3 : Symbol(F2or3, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 71, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const F3: F<3>;
>F3 : Symbol(F3, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 72, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const Fstring: F<"">;
>Fstring : Symbol(Fstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 73, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const Fempty: F<{}>;
>Fempty : Symbol(Fempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 74, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const Fnever: F<never>;
>Fnever : Symbol(Fnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 75, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const Fany: F<any>;
>Fany : Symbol(Fany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 76, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
declare const Fundefined: F<undefined>;
>Fundefined : Symbol(Fundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 13))
>F : Symbol(F, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 61, 39))
// never
type G<T> = T match {
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 80, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 80, 7))
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
>G1 : Symbol(G1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 85, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const G1or2: G<1 | 2>;
>G1or2 : Symbol(G1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 86, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const Gstring: G<"">;
>Gstring : Symbol(Gstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 87, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const Gempty: G<{}>;
>Gempty : Symbol(Gempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 88, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const Gnever: G<never>;
>Gnever : Symbol(Gnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 89, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const Gany: G<any>;
>Gany : Symbol(Gany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 90, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
declare const Gundefined: G<undefined>;
>Gundefined : Symbol(Gundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 13))
>G : Symbol(G, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 77, 39))
// undefined
type H<T> = T match {
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 94, 7))
>T : Symbol(T, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 94, 7))
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
>H1 : Symbol(H1, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 99, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const H1or2: H<1 | 2>;
>H1or2 : Symbol(H1or2, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 100, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const Hstring: H<"">;
>Hstring : Symbol(Hstring, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 101, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const Hempty: H<{}>;
>Hempty : Symbol(Hempty, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 102, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const Hnever: H<never>;
>Hnever : Symbol(Hnever, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 103, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const Hany: H<any>;
>Hany : Symbol(Hany, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 104, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))
declare const Hundefined: H<undefined>;
>Hundefined : Symbol(Hundefined, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 105, 13))
>H : Symbol(H, Decl(matchGenericTypeArgumentStrictNullChecks.ts, 91, 39))

309
tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.types Normal file
View File

@ -0,0 +1,309 @@
=== tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts ===
// all of these test `match` with generics and --strictNullChecks.
// empty
type A<T> = T match {
>A : never
>T : T
>T : T
};
declare const A1: A<1>;
>A1 : never
>A : never
declare const A1or2: A<1 | 2>;
>A1or2 : never
>A : never
declare const Astring: A<"">;
>Astring : never
>A : never
declare const Aempty: A<{}>;
>Aempty : never
>A : never
declare const Anever: A<never>;
>Anever : never
>A : never
declare const Aany: A<any>;
>Aany : never
>A : never
declare const Aundefined: A<undefined>;
>Aundefined : never
>A : never
// only else
type B<T> = T match {
>B : "else"
>T : T
>T : T
else: "else"
};
declare const B1: B<1>;
>B1 : "else"
>B : "else"
declare const B1or2: B<1 | 2>;
>B1or2 : "else"
>B : "else"
declare const Bstring: B<"">;
>Bstring : "else"
>B : "else"
declare const Bempty: B<{}>;
>Bempty : "else"
>B : "else"
declare const Bnever: B<never>;
>Bnever : "else"
>B : "else"
declare const Bany: B<any>;
>Bany : "else"
>B : "else"
declare const Bundefined: B<undefined>;
>Bundefined : "else"
>B : "else"
// only one exact match, no else
type C<T> = T match {
>C : C<T>
>T : T
>T : T
1: "1"
};
declare const C1: C<1>;
>C1 : "1"
>C : C<T>
declare const C1or2: C<1 | 2>;
>C1or2 : "1"
>C : C<T>
declare const Cstring: C<"">;
>Cstring : never
>C : C<T>
declare const Cempty: C<{}>;
>Cempty : never
>C : C<T>
declare const Cnever: C<never>;
>Cnever : "1"
>C : C<T>
declare const Cany: C<any>;
>Cany : "1"
>C : C<T>
declare const Cundefined: C<undefined>;
>Cundefined : never
>C : C<T>
// only one subtype match, no else
type D<T> = T match {
>D : D<T>
>T : T
>T : T
number: "number"
};
declare const D1: D<1>;
>D1 : "number"
>D : D<T>
declare const D1or2: D<1 | 2>;
>D1or2 : "number"
>D : D<T>
declare const Dstring: D<"">;
>Dstring : never
>D : D<T>
declare const Dempty: D<{}>;
>Dempty : never
>D : D<T>
declare const Dnever: D<never>;
>Dnever : "number"
>D : D<T>
declare const Dany: D<any>;
>Dany : "number"
>D : D<T>
declare const Dundefined: D<undefined>;
>Dundefined : never
>D : D<T>
// multiple possible subtype matches, no else
type E<T> = T match {
>E : E<T>
>T : T
>T : T
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
>E1 : "1 | 2"
>E : E<T>
declare const E1or2: E<1 | 2>;
>E1or2 : "1 | 2"
>E : E<T>
declare const E3: E<3>;
>E3 : "number"
>E : E<T>
declare const Estring: E<"">;
>Estring : never
>E : E<T>
declare const Eempty: E<{}>;
>Eempty : never
>E : E<T>
declare const Enever: E<never>;
>Enever : "1 | 2"
>E : E<T>
declare const Eany: E<any>;
>Eany : "1 | 2"
>E : E<T>
declare const Eundefined: E<undefined>;
>Eundefined : never
>E : E<T>
// multiple possible matches (subtype first), no else
type F<T> = T match {
>F : F<T>
>T : T
>T : T
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
>F1 : "1 | 2"
>F : F<T>
declare const F1or2: F<1 | 2>;
>F1or2 : "1 | 2"
>F : F<T>
declare const F2or3: F<2 | 3>;
>F2or3 : "number" | "1 | 2"
>F : F<T>
declare const F3: F<3>;
>F3 : "number"
>F : F<T>
declare const Fstring: F<"">;
>Fstring : never
>F : F<T>
declare const Fempty: F<{}>;
>Fempty : never
>F : F<T>
declare const Fnever: F<never>;
>Fnever : "1 | 2"
>F : F<T>
declare const Fany: F<any>;
>Fany : "1 | 2"
>F : F<T>
declare const Fundefined: F<undefined>;
>Fundefined : never
>F : F<T>
// never
type G<T> = T match {
>G : G<T>
>T : T
>T : T
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
>G1 : "number"
>G : G<T>
declare const G1or2: G<1 | 2>;
>G1or2 : "number"
>G : G<T>
declare const Gstring: G<"">;
>Gstring : "else"
>G : G<T>
declare const Gempty: G<{}>;
>Gempty : "else"
>G : G<T>
declare const Gnever: G<never>;
>Gnever : "never"
>G : G<T>
declare const Gany: G<any>;
>Gany : "number"
>G : G<T>
declare const Gundefined: G<undefined>;
>Gundefined : "else"
>G : G<T>
// undefined
type H<T> = T match {
>H : H<T>
>T : T
>T : T
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
>H1 : "number"
>H : H<T>
declare const H1or2: H<1 | 2>;
>H1or2 : "number"
>H : H<T>
declare const Hstring: H<"">;
>Hstring : "else"
>H : H<T>
declare const Hempty: H<{}>;
>Hempty : "else"
>H : H<T>
declare const Hnever: H<never>;
>Hnever : "undefined"
>H : H<T>
declare const Hany: H<any>;
>Hany : "undefined"
>H : H<T>
declare const Hundefined: H<undefined>;
>Hundefined : "undefined"
>H : H<T>

106
tests/baselines/reference/matchNonGeneric.js Normal file
View File

@ -0,0 +1,106 @@
//// [matchNonGeneric.ts]
// all of these test `match` in basic scenarios where we can eagerly compute the resulting type.
// empty
declare const A: 1 match {
};
// only else
declare const B: 1 match {
else: "else"
};
// only one exact match, no else
declare const C: 1 match {
1: "1"
};
// only one subtype match, no else
declare const D: 1 match {
number: "number"
};
// multiple possible subtype matches, no else
declare const E: 1 match {
1 | 2: "1 | 2",
number: "number"
};
// multiple possible matches (subtype match first), no else
declare const F: 1 match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
// no match, no else
declare const G: 1 match {
string: "string"
};
// no match, else
declare const H: 1 match {
string: "string",
else: "else"
};
// union, both match, no else
declare const I: (1 | 2) match {
1: "1",
2: "2"
};
// union, one match, no else
declare const J: (1 | 2) match {
1: "1"
};
// union, one match, else
declare const K: (1 | 2) match {
1: "1",
else: "else"
};
//// [matchNonGeneric.js]
// all of these test `match` in basic scenarios where we can eagerly compute the resulting type.
//// [matchNonGeneric.d.ts]
declare const A: 1 match {};
declare const B: 1 match {
else: "else"
};
declare const C: 1 match {
1: "1"
};
declare const D: 1 match {
number: "number"
};
declare const E: 1 match {
1 | 2: "1 | 2",
number: "number"
};
declare const F: 1 match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const G: 1 match {
string: "string"
};
declare const H: 1 match {
string: "string",
else: "else"
};
declare const I: (1 | 2) match {
1: "1",
2: "2"
};
declare const J: (1 | 2) match {
1: "1"
};
declare const K: (1 | 2) match {
1: "1",
else: "else"
};

85
tests/baselines/reference/matchNonGeneric.symbols Normal file
View File

@ -0,0 +1,85 @@
=== tests/cases/conformance/types/match/matchNonGeneric.ts ===
// all of these test `match` in basic scenarios where we can eagerly compute the resulting type.
// empty
declare const A: 1 match {
>A : Symbol(A, Decl(matchNonGeneric.ts, 3, 13))
};
// only else
declare const B: 1 match {
>B : Symbol(B, Decl(matchNonGeneric.ts, 7, 13))
else: "else"
};
// only one exact match, no else
declare const C: 1 match {
>C : Symbol(C, Decl(matchNonGeneric.ts, 12, 13))
1: "1"
};
// only one subtype match, no else
declare const D: 1 match {
>D : Symbol(D, Decl(matchNonGeneric.ts, 17, 13))
number: "number"
};
// multiple possible subtype matches, no else
declare const E: 1 match {
>E : Symbol(E, Decl(matchNonGeneric.ts, 22, 13))
1 | 2: "1 | 2",
number: "number"
};
// multiple possible matches (subtype match first), no else
declare const F: 1 match {
>F : Symbol(F, Decl(matchNonGeneric.ts, 28, 13))
1 | 2: "1 | 2",
1: "1",
number: "number"
};
// no match, no else
declare const G: 1 match {
>G : Symbol(G, Decl(matchNonGeneric.ts, 35, 13))
string: "string"
};
// no match, else
declare const H: 1 match {
>H : Symbol(H, Decl(matchNonGeneric.ts, 40, 13))
string: "string",
else: "else"
};
// union, both match, no else
declare const I: (1 | 2) match {
>I : Symbol(I, Decl(matchNonGeneric.ts, 46, 13))
1: "1",
2: "2"
};
// union, one match, no else
declare const J: (1 | 2) match {
>J : Symbol(J, Decl(matchNonGeneric.ts, 52, 13))
1: "1"
};
// union, one match, else
declare const K: (1 | 2) match {
>K : Symbol(K, Decl(matchNonGeneric.ts, 57, 13))
1: "1",
else: "else"
};

85
tests/baselines/reference/matchNonGeneric.types Normal file
View File

@ -0,0 +1,85 @@
=== tests/cases/conformance/types/match/matchNonGeneric.ts ===
// all of these test `match` in basic scenarios where we can eagerly compute the resulting type.
// empty
declare const A: 1 match {
>A : never
};
// only else
declare const B: 1 match {
>B : "else"
else: "else"
};
// only one exact match, no else
declare const C: 1 match {
>C : "1"
1: "1"
};
// only one subtype match, no else
declare const D: 1 match {
>D : "number"
number: "number"
};
// multiple possible subtype matches, no else
declare const E: 1 match {
>E : "1 | 2"
1 | 2: "1 | 2",
number: "number"
};
// multiple possible matches (subtype match first), no else
declare const F: 1 match {
>F : "1 | 2"
1 | 2: "1 | 2",
1: "1",
number: "number"
};
// no match, no else
declare const G: 1 match {
>G : never
string: "string"
};
// no match, else
declare const H: 1 match {
>H : "else"
string: "string",
else: "else"
};
// union, both match, no else
declare const I: (1 | 2) match {
>I : "1" | "2"
1: "1",
2: "2"
};
// union, one match, no else
declare const J: (1 | 2) match {
>J : "1"
1: "1"
};
// union, one match, else
declare const K: (1 | 2) match {
>K : "else" | "1"
1: "1",
else: "else"
};

150
tests/cases/conformance/types/match/matchGenericTypeArgument.ts Normal file
View File

@ -0,0 +1,150 @@
// @declaration: true
// all of these test `match` with generics.
// empty
type A<T> = T match {
};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
// only else
type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
// only one exact match, no else
type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
// only one subtype match, no else
type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
// multiple possible subtype matches, no else
type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
// multiple possible matches (subtype first), no else
type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
// never
type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
// undefined
type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;
// union, both match, no else
type I<T, U> = (T | U) match {
1: "1",
2: "2"
};
declare const I11: I<1, 1>;
declare const I12: I<1, 2>;
declare const I11or2: I<1, 1 | 2>;
declare const I1string: I<1, "">;
declare const I1empty: I<1, {}>;
declare const I1never: I<1, never>;
declare const I1any: I<1, any>;
declare const I1undefined: I<1, undefined>;
// union, one match, no else
type J<T, U> = (T | U) match {
1: "1"
};
declare const J11: J<1, 1>;
declare const J12: J<1, 2>;
declare const J22: J<2, 2>;
declare const J11or2: J<1, 1 | 2>;
declare const J1string: J<1, "">;
declare const J1empty: J<1, {}>;
declare const J1never: J<1, never>;
declare const J1any: J<1, any>;
declare const J1undefined: J<1, undefined>;
// union, one match, else
type K<T, U> = (T | U) match {
1: "1",
else: "else"
};
declare const K11: K<1, 1>;
declare const K12: K<1, 2>;
declare const K22: K<2, 2>;
declare const K11or2: K<1, 1 | 2>;
declare const K1string: K<1, "">;
declare const K1empty: K<1, {}>;
declare const K1never: K<1, never>;
declare const K1any: K<1, any>;
declare const K1undefined: K<1, undefined>;

108
tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts Normal file
View File

@ -0,0 +1,108 @@
// @declaration: true
// @strictNullChecks: true
// all of these test `match` with generics and --strictNullChecks.
// empty
type A<T> = T match {
};
declare const A1: A<1>;
declare const A1or2: A<1 | 2>;
declare const Astring: A<"">;
declare const Aempty: A<{}>;
declare const Anever: A<never>;
declare const Aany: A<any>;
declare const Aundefined: A<undefined>;
// only else
type B<T> = T match {
else: "else"
};
declare const B1: B<1>;
declare const B1or2: B<1 | 2>;
declare const Bstring: B<"">;
declare const Bempty: B<{}>;
declare const Bnever: B<never>;
declare const Bany: B<any>;
declare const Bundefined: B<undefined>;
// only one exact match, no else
type C<T> = T match {
1: "1"
};
declare const C1: C<1>;
declare const C1or2: C<1 | 2>;
declare const Cstring: C<"">;
declare const Cempty: C<{}>;
declare const Cnever: C<never>;
declare const Cany: C<any>;
declare const Cundefined: C<undefined>;
// only one subtype match, no else
type D<T> = T match {
number: "number"
};
declare const D1: D<1>;
declare const D1or2: D<1 | 2>;
declare const Dstring: D<"">;
declare const Dempty: D<{}>;
declare const Dnever: D<never>;
declare const Dany: D<any>;
declare const Dundefined: D<undefined>;
// multiple possible subtype matches, no else
type E<T> = T match {
1 | 2: "1 | 2",
number: "number"
};
declare const E1: E<1>;
declare const E1or2: E<1 | 2>;
declare const E3: E<3>;
declare const Estring: E<"">;
declare const Eempty: E<{}>;
declare const Enever: E<never>;
declare const Eany: E<any>;
declare const Eundefined: E<undefined>;
// multiple possible matches (subtype first), no else
type F<T> = T match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
declare const F1: F<1>;
declare const F1or2: F<1 | 2>;
declare const F2or3: F<2 | 3>;
declare const F3: F<3>;
declare const Fstring: F<"">;
declare const Fempty: F<{}>;
declare const Fnever: F<never>;
declare const Fany: F<any>;
declare const Fundefined: F<undefined>;
// never
type G<T> = T match {
never: "never",
number: "number",
else: "else"
};
declare const G1: G<1>;
declare const G1or2: G<1 | 2>;
declare const Gstring: G<"">;
declare const Gempty: G<{}>;
declare const Gnever: G<never>;
declare const Gany: G<any>;
declare const Gundefined: G<undefined>;
// undefined
type H<T> = T match {
undefined: "undefined",
number: "number",
else: "else"
};
declare const H1: H<1>;
declare const H1or2: H<1 | 2>;
declare const Hstring: H<"">;
declare const Hempty: H<{}>;
declare const Hnever: H<never>;
declare const Hany: H<any>;
declare const Hundefined: H<undefined>;

62
tests/cases/conformance/types/match/matchNonGeneric.ts Normal file
View File

@ -0,0 +1,62 @@
// @declaration: true
// all of these test `match` in basic scenarios where we can eagerly compute the resulting type.
// empty
declare const A: 1 match {
};
// only else
declare const B: 1 match {
else: "else"
};
// only one exact match, no else
declare const C: 1 match {
1: "1"
};
// only one subtype match, no else
declare const D: 1 match {
number: "number"
};
// multiple possible subtype matches, no else
declare const E: 1 match {
1 | 2: "1 | 2",
number: "number"
};
// multiple possible matches (subtype match first), no else
declare const F: 1 match {
1 | 2: "1 | 2",
1: "1",
number: "number"
};
// no match, no else
declare const G: 1 match {
string: "string"
};
// no match, else
declare const H: 1 match {
string: "string",
else: "else"
};
// union, both match, no else
declare const I: (1 | 2) match {
1: "1",
2: "2"
};
// union, one match, no else
declare const J: (1 | 2) match {
1: "1"
};
// union, one match, else
declare const K: (1 | 2) match {
1: "1",
else: "else"
};