diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d8c0b99b708..8bf15bcd8b4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -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;
         }
 
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 1c01f1aab93..67af9921a17 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1125,6 +1125,7 @@ namespace ts {
 
         function emitMatchType(node: MatchTypeNode) {
             emit(node.typeArgument);
+            write(" ");
             writeToken(SyntaxKind.MatchKeyword, node.typeArgument.end);
             write(" ");
             emit(node.matchBlock);
diff --git a/tests/baselines/reference/matchGenericTypeArgument.js b/tests/baselines/reference/matchGenericTypeArgument.js
new file mode 100644
index 00000000000..ad62614128c
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgument.js
@@ -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>;
diff --git a/tests/baselines/reference/matchGenericTypeArgument.symbols b/tests/baselines/reference/matchGenericTypeArgument.symbols
new file mode 100644
index 00000000000..e8e501dec90
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgument.symbols
@@ -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))
+
diff --git a/tests/baselines/reference/matchGenericTypeArgument.types b/tests/baselines/reference/matchGenericTypeArgument.types
new file mode 100644
index 00000000000..750b955ca42
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgument.types
@@ -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>
+
diff --git a/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.js b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.js
new file mode 100644
index 00000000000..bb304f237f4
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.js
@@ -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>;
diff --git a/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.symbols b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.symbols
new file mode 100644
index 00000000000..767b53c69cc
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.symbols
@@ -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))
+
diff --git a/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.types b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.types
new file mode 100644
index 00000000000..764fbc6f552
--- /dev/null
+++ b/tests/baselines/reference/matchGenericTypeArgumentStrictNullChecks.types
@@ -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>
+
diff --git a/tests/baselines/reference/matchNonGeneric.js b/tests/baselines/reference/matchNonGeneric.js
new file mode 100644
index 00000000000..2aaa7d19569
--- /dev/null
+++ b/tests/baselines/reference/matchNonGeneric.js
@@ -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"
+};
diff --git a/tests/baselines/reference/matchNonGeneric.symbols b/tests/baselines/reference/matchNonGeneric.symbols
new file mode 100644
index 00000000000..d21d8846000
--- /dev/null
+++ b/tests/baselines/reference/matchNonGeneric.symbols
@@ -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"
+};
+
diff --git a/tests/baselines/reference/matchNonGeneric.types b/tests/baselines/reference/matchNonGeneric.types
new file mode 100644
index 00000000000..bb4386acb1e
--- /dev/null
+++ b/tests/baselines/reference/matchNonGeneric.types
@@ -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"
+};
+
diff --git a/tests/cases/conformance/types/match/matchGenericTypeArgument.ts b/tests/cases/conformance/types/match/matchGenericTypeArgument.ts
new file mode 100644
index 00000000000..c02ba3107a6
--- /dev/null
+++ b/tests/cases/conformance/types/match/matchGenericTypeArgument.ts
@@ -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>;
\ No newline at end of file
diff --git a/tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts b/tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts
new file mode 100644
index 00000000000..b2e3d73b6c6
--- /dev/null
+++ b/tests/cases/conformance/types/match/matchGenericTypeArgumentStrictNullChecks.ts
@@ -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>;
diff --git a/tests/cases/conformance/types/match/matchNonGeneric.ts b/tests/cases/conformance/types/match/matchNonGeneric.ts
new file mode 100644
index 00000000000..62817769f4d
--- /dev/null
+++ b/tests/cases/conformance/types/match/matchNonGeneric.ts
@@ -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"
+};