diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 58248a8a9ee75..5454002fe70ba 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -9062,6 +9062,13 @@ namespace ts {
                         (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) {
                         return false;
                     }
+                    if (target.flags & TypeFlags.Union) {
+                        const discriminantType = findMatchingDiscriminantType(source, target as UnionType);
+                        if (discriminantType)  {
+                            // check excess properties against discriminant type only, not the entire union
+                            return hasExcessProperties(source, discriminantType, reportErrors);
+                        }
+                    }
                     for (const prop of getPropertiesOfObjectType(source)) {
                         if (!isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -9138,20 +9145,24 @@ namespace ts {
             }
 
             function findMatchingDiscriminantType(source: Type, target: UnionOrIntersectionType) {
+                let match: Type;
                 const sourceProperties = getPropertiesOfObjectType(source);
                 if (sourceProperties) {
-                    for (const sourceProperty of sourceProperties) {
-                        if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
-                            const sourceType = getTypeOfSymbol(sourceProperty);
-                            for (const type of target.types) {
-                                const targetType = getTypeOfPropertyOfType(type, sourceProperty.escapedName);
-                                if (targetType && isRelatedTo(sourceType, targetType)) {
-                                    return type;
+                    const sourceProperty = findSingleDiscriminantProperty(sourceProperties, target);
+                    if (sourceProperty) {
+                        const sourceType = getTypeOfSymbol(sourceProperty);
+                        for (const type of target.types) {
+                            const targetType = getTypeOfPropertyOfType(type, sourceProperty.escapedName);
+                            if (targetType && isRelatedTo(sourceType, targetType)) {
+                                if (match) {
+                                    return undefined;
                                 }
+                                match = type;
                             }
                         }
                     }
                 }
+                return match;
             }
 
             function typeRelatedToEachType(source: Type, target: IntersectionType, reportErrors: boolean): Ternary {
@@ -11154,6 +11165,19 @@ namespace ts {
             return false;
         }
 
+        function findSingleDiscriminantProperty(sourceProperties: Symbol[], target: Type): Symbol | undefined {
+            let result: Symbol;
+            for (const sourceProperty of sourceProperties) {
+                if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
+                    if (result) {
+                        return undefined;
+                    }
+                    result = sourceProperty;
+                }
+            }
+            return result;
+        }
+
         function isOrContainsMatchingReference(source: Node, target: Node) {
             return isMatchingReference(source, target) || containsMatchingReference(source, target);
         }
diff --git a/tests/baselines/reference/discriminatedUnionErrorMessage.errors.txt b/tests/baselines/reference/discriminatedUnionErrorMessage.errors.txt
index 6f1eb511d3714..e54727befd0e1 100644
--- a/tests/baselines/reference/discriminatedUnionErrorMessage.errors.txt
+++ b/tests/baselines/reference/discriminatedUnionErrorMessage.errors.txt
@@ -1,6 +1,5 @@
-tests/cases/compiler/discriminatedUnionErrorMessage.ts(8,5): error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
-  Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Square'.
-    Property 'size' is missing in type '{ kind: "sq"; x: number; y: number; }'.
+tests/cases/compiler/discriminatedUnionErrorMessage.ts(10,5): error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
+  Object literal may only specify known properties, and 'x' does not exist in type 'Square'.
 
 
 ==== tests/cases/compiler/discriminatedUnionErrorMessage.ts (1 errors) ====
@@ -12,12 +11,11 @@ tests/cases/compiler/discriminatedUnionErrorMessage.ts(8,5): error TS2322: Type
         | Rectangle
         | Circle;
     let shape: Shape = {
-        ~~~~~
-!!! error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
-!!! error TS2322:   Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Square'.
-!!! error TS2322:     Property 'size' is missing in type '{ kind: "sq"; x: number; y: number; }'.
         kind: "sq",
         x: 12,
+        ~~~~~
+!!! error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
+!!! error TS2322:   Object literal may only specify known properties, and 'x' does not exist in type 'Square'.
         y: 13,
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.errors.txt b/tests/baselines/reference/excessPropertyCheckWithUnions.errors.txt
new file mode 100644
index 0000000000000..3b7e5a787d2aa
--- /dev/null
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.errors.txt
@@ -0,0 +1,99 @@
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(10,30): error TS2322: Type '{ tag: "T"; a1: string; }' is not assignable to type 'ADT'.
+  Object literal may only specify known properties, and 'a1' does not exist in type '{ tag: "T"; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(11,21): error TS2322: Type '{ tag: "A"; d20: 12; }' is not assignable to type 'ADT'.
+  Object literal may only specify known properties, and 'd20' does not exist in type '{ tag: "A"; a1: string; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(12,1): error TS2322: Type '{ tag: "D"; }' is not assignable to type 'ADT'.
+  Type '{ tag: "D"; }' is not assignable to type '{ tag: "D"; d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; }'.
+    Property 'd20' is missing in type '{ tag: "D"; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(33,28): error TS2322: Type '{ tag: "A"; x: string; extra: number; }' is not assignable to type 'Ambiguous'.
+  Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(34,26): error TS2322: Type '{ tag: "A"; y: number; extra: number; }' is not assignable to type 'Ambiguous'.
+  Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(39,1): error TS2322: Type '{ tag: "A"; }' is not assignable to type 'Ambiguous'.
+  Type '{ tag: "A"; }' is not assignable to type '{ tag: "C"; }'.
+    Types of property 'tag' are incompatible.
+      Type '"A"' is not assignable to type '"C"'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(40,1): error TS2322: Type '{ tag: "A"; z: true; }' is not assignable to type 'Ambiguous'.
+  Type '{ tag: "A"; z: true; }' is not assignable to type '{ tag: "C"; }'.
+    Types of property 'tag' are incompatible.
+      Type '"A"' is not assignable to type '"C"'.
+
+
+==== tests/cases/compiler/excessPropertyCheckWithUnions.ts (7 errors) ====
+    type ADT = {
+        tag: "A",
+        a1: string
+    } | {
+        tag: "D",
+        d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+    } | {
+        tag: "T",
+    }
+    let wrong: ADT = { tag: "T", a1: "extra" }
+                                 ~~~~~~~~~~~
+!!! error TS2322: Type '{ tag: "T"; a1: string; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Object literal may only specify known properties, and 'a1' does not exist in type '{ tag: "T"; }'.
+    wrong = { tag: "A", d20: 12 }
+                        ~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; d20: 12; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Object literal may only specify known properties, and 'd20' does not exist in type '{ tag: "A"; a1: string; }'.
+    wrong = { tag: "D" }
+    ~~~~~
+!!! error TS2322: Type '{ tag: "D"; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Type '{ tag: "D"; }' is not assignable to type '{ tag: "D"; d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; }'.
+!!! error TS2322:     Property 'd20' is missing in type '{ tag: "D"; }'.
+    
+    type Ambiguous = {
+        tag: "A",
+        x: string
+    } | {
+        tag: "A",
+        y: number
+    } | {
+        tag: "B",
+        z: boolean
+    } | {
+        tag: "C"
+    }
+    let amb: Ambiguous
+    // no error for ambiguous tag, even when it could satisfy both constituents at once
+    amb = { tag: "A", x: "hi" }
+    amb = { tag: "A", y: 12 }
+    amb = { tag: "A", x: "hi", y: 12 }
+    
+    // correctly error on excess property 'extra', even when ambiguous
+    amb = { tag: "A", x: "hi", extra: 12 }
+                               ~~~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; x: string; extra: number; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+    amb = { tag: "A", y: 12, extra: 12 }
+                             ~~~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; y: number; extra: number; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+    
+    // assignability errors still work.
+    // But note that the error for `z: true` is the fallback one of reporting on
+    // the last constituent since assignability error reporting can't find a single best discriminant either.
+    amb = { tag: "A" }
+    ~~~
+!!! error TS2322: Type '{ tag: "A"; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Type '{ tag: "A"; }' is not assignable to type '{ tag: "C"; }'.
+!!! error TS2322:     Types of property 'tag' are incompatible.
+!!! error TS2322:       Type '"A"' is not assignable to type '"C"'.
+    amb = { tag: "A", z: true }
+    ~~~
+!!! error TS2322: Type '{ tag: "A"; z: true; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Type '{ tag: "A"; z: true; }' is not assignable to type '{ tag: "C"; }'.
+!!! error TS2322:     Types of property 'tag' are incompatible.
+!!! error TS2322:       Type '"A"' is not assignable to type '"C"'.
+    
+    type Overlapping =
+        | { a: 1, b: 1, first: string }
+        | { a: 2, second: string }
+        | { b: 3, third: string }
+    let over: Overlapping
+    
+    // these two are not reported because there are two discriminant properties
+    over = { a: 1, b: 1, first: "ok", second: "error" }
+    over = { a: 1, b: 1, first: "ok", third: "error" }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.js b/tests/baselines/reference/excessPropertyCheckWithUnions.js
new file mode 100644
index 0000000000000..c6da660b52dde
--- /dev/null
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.js
@@ -0,0 +1,74 @@
+//// [excessPropertyCheckWithUnions.ts]
+type ADT = {
+    tag: "A",
+    a1: string
+} | {
+    tag: "D",
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+} | {
+    tag: "T",
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+wrong = { tag: "A", d20: 12 }
+wrong = { tag: "D" }
+
+type Ambiguous = {
+    tag: "A",
+    x: string
+} | {
+    tag: "A",
+    y: number
+} | {
+    tag: "B",
+    z: boolean
+} | {
+    tag: "C"
+}
+let amb: Ambiguous
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+amb = { tag: "A", y: 12 }
+amb = { tag: "A", x: "hi", y: 12 }
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+amb = { tag: "A", y: 12, extra: 12 }
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+amb = { tag: "A", z: true }
+
+type Overlapping =
+    | { a: 1, b: 1, first: string }
+    | { a: 2, second: string }
+    | { b: 3, third: string }
+let over: Overlapping
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+over = { a: 1, b: 1, first: "ok", third: "error" }
+
+
+//// [excessPropertyCheckWithUnions.js]
+var wrong = { tag: "T", a1: "extra" };
+wrong = { tag: "A", d20: 12 };
+wrong = { tag: "D" };
+var amb;
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" };
+amb = { tag: "A", y: 12 };
+amb = { tag: "A", x: "hi", y: 12 };
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 };
+amb = { tag: "A", y: 12, extra: 12 };
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" };
+amb = { tag: "A", z: true };
+var over;
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" };
+over = { a: 1, b: 1, first: "ok", third: "error" };
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.symbols b/tests/baselines/reference/excessPropertyCheckWithUnions.symbols
new file mode 100644
index 0000000000000..332166e396c8f
--- /dev/null
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.symbols
@@ -0,0 +1,144 @@
+=== tests/cases/compiler/excessPropertyCheckWithUnions.ts ===
+type ADT = {
+>ADT : Symbol(ADT, Decl(excessPropertyCheckWithUnions.ts, 0, 0))
+
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 0, 12))
+
+    a1: string
+>a1 : Symbol(a1, Decl(excessPropertyCheckWithUnions.ts, 1, 13))
+
+} | {
+    tag: "D",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 3, 5))
+
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+>d20 : Symbol(d20, Decl(excessPropertyCheckWithUnions.ts, 4, 13))
+
+} | {
+    tag: "T",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 6, 5))
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>ADT : Symbol(ADT, Decl(excessPropertyCheckWithUnions.ts, 0, 0))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 9, 18))
+>a1 : Symbol(a1, Decl(excessPropertyCheckWithUnions.ts, 9, 28))
+
+wrong = { tag: "A", d20: 12 }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 10, 9))
+>d20 : Symbol(d20, Decl(excessPropertyCheckWithUnions.ts, 10, 19))
+
+wrong = { tag: "D" }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 11, 9))
+
+type Ambiguous = {
+>Ambiguous : Symbol(Ambiguous, Decl(excessPropertyCheckWithUnions.ts, 11, 20))
+
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 13, 18))
+
+    x: string
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 14, 13))
+
+} | {
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 16, 5))
+
+    y: number
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 17, 13))
+
+} | {
+    tag: "B",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 19, 5))
+
+    z: boolean
+>z : Symbol(z, Decl(excessPropertyCheckWithUnions.ts, 20, 13))
+
+} | {
+    tag: "C"
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 22, 5))
+}
+let amb: Ambiguous
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>Ambiguous : Symbol(Ambiguous, Decl(excessPropertyCheckWithUnions.ts, 11, 20))
+
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 27, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 27, 17))
+
+amb = { tag: "A", y: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 28, 7))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 28, 17))
+
+amb = { tag: "A", x: "hi", y: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 29, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 29, 17))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 29, 26))
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 32, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 32, 17))
+>extra : Symbol(extra, Decl(excessPropertyCheckWithUnions.ts, 32, 26))
+
+amb = { tag: "A", y: 12, extra: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 33, 7))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 33, 17))
+>extra : Symbol(extra, Decl(excessPropertyCheckWithUnions.ts, 33, 24))
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 38, 7))
+
+amb = { tag: "A", z: true }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 39, 7))
+>z : Symbol(z, Decl(excessPropertyCheckWithUnions.ts, 39, 17))
+
+type Overlapping =
+>Overlapping : Symbol(Overlapping, Decl(excessPropertyCheckWithUnions.ts, 39, 27))
+
+    | { a: 1, b: 1, first: string }
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 42, 7))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 42, 13))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 42, 19))
+
+    | { a: 2, second: string }
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 43, 7))
+>second : Symbol(second, Decl(excessPropertyCheckWithUnions.ts, 43, 13))
+
+    | { b: 3, third: string }
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 44, 7))
+>third : Symbol(third, Decl(excessPropertyCheckWithUnions.ts, 44, 13))
+
+let over: Overlapping
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>Overlapping : Symbol(Overlapping, Decl(excessPropertyCheckWithUnions.ts, 39, 27))
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 48, 8))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 48, 14))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 48, 20))
+>second : Symbol(second, Decl(excessPropertyCheckWithUnions.ts, 48, 33))
+
+over = { a: 1, b: 1, first: "ok", third: "error" }
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 49, 8))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 49, 14))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 49, 20))
+>third : Symbol(third, Decl(excessPropertyCheckWithUnions.ts, 49, 33))
+
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.types b/tests/baselines/reference/excessPropertyCheckWithUnions.types
new file mode 100644
index 0000000000000..1d6bdd32eb269
--- /dev/null
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.types
@@ -0,0 +1,196 @@
+=== tests/cases/compiler/excessPropertyCheckWithUnions.ts ===
+type ADT = {
+>ADT : ADT
+
+    tag: "A",
+>tag : "A"
+
+    a1: string
+>a1 : string
+
+} | {
+    tag: "D",
+>tag : "D"
+
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+>d20 : 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+
+} | {
+    tag: "T",
+>tag : "T"
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+>wrong : ADT
+>ADT : ADT
+>{ tag: "T", a1: "extra" } : { tag: "T"; a1: string; }
+>tag : string
+>"T" : "T"
+>a1 : string
+>"extra" : "extra"
+
+wrong = { tag: "A", d20: 12 }
+>wrong = { tag: "A", d20: 12 } : { tag: "A"; d20: 12; }
+>wrong : ADT
+>{ tag: "A", d20: 12 } : { tag: "A"; d20: 12; }
+>tag : string
+>"A" : "A"
+>d20 : number
+>12 : 12
+
+wrong = { tag: "D" }
+>wrong = { tag: "D" } : { tag: "D"; }
+>wrong : ADT
+>{ tag: "D" } : { tag: "D"; }
+>tag : string
+>"D" : "D"
+
+type Ambiguous = {
+>Ambiguous : Ambiguous
+
+    tag: "A",
+>tag : "A"
+
+    x: string
+>x : string
+
+} | {
+    tag: "A",
+>tag : "A"
+
+    y: number
+>y : number
+
+} | {
+    tag: "B",
+>tag : "B"
+
+    z: boolean
+>z : boolean
+
+} | {
+    tag: "C"
+>tag : "C"
+}
+let amb: Ambiguous
+>amb : Ambiguous
+>Ambiguous : Ambiguous
+
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+>amb = { tag: "A", x: "hi" } : { tag: "A"; x: string; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi" } : { tag: "A"; x: string; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+
+amb = { tag: "A", y: 12 }
+>amb = { tag: "A", y: 12 } : { tag: "A"; y: number; }
+>amb : Ambiguous
+>{ tag: "A", y: 12 } : { tag: "A"; y: number; }
+>tag : string
+>"A" : "A"
+>y : number
+>12 : 12
+
+amb = { tag: "A", x: "hi", y: 12 }
+>amb = { tag: "A", x: "hi", y: 12 } : { tag: "A"; x: string; y: number; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi", y: 12 } : { tag: "A"; x: string; y: number; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+>y : number
+>12 : 12
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+>amb = { tag: "A", x: "hi", extra: 12 } : { tag: "A"; x: string; extra: number; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi", extra: 12 } : { tag: "A"; x: string; extra: number; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+>extra : number
+>12 : 12
+
+amb = { tag: "A", y: 12, extra: 12 }
+>amb = { tag: "A", y: 12, extra: 12 } : { tag: "A"; y: number; extra: number; }
+>amb : Ambiguous
+>{ tag: "A", y: 12, extra: 12 } : { tag: "A"; y: number; extra: number; }
+>tag : string
+>"A" : "A"
+>y : number
+>12 : 12
+>extra : number
+>12 : 12
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+>amb = { tag: "A" } : { tag: "A"; }
+>amb : Ambiguous
+>{ tag: "A" } : { tag: "A"; }
+>tag : string
+>"A" : "A"
+
+amb = { tag: "A", z: true }
+>amb = { tag: "A", z: true } : { tag: "A"; z: true; }
+>amb : Ambiguous
+>{ tag: "A", z: true } : { tag: "A"; z: true; }
+>tag : string
+>"A" : "A"
+>z : boolean
+>true : true
+
+type Overlapping =
+>Overlapping : Overlapping
+
+    | { a: 1, b: 1, first: string }
+>a : 1
+>b : 1
+>first : string
+
+    | { a: 2, second: string }
+>a : 2
+>second : string
+
+    | { b: 3, third: string }
+>b : 3
+>third : string
+
+let over: Overlapping
+>over : Overlapping
+>Overlapping : Overlapping
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+>over = { a: 1, b: 1, first: "ok", second: "error" } : { a: 1; b: 1; first: string; second: string; }
+>over : Overlapping
+>{ a: 1, b: 1, first: "ok", second: "error" } : { a: 1; b: 1; first: string; second: string; }
+>a : number
+>1 : 1
+>b : number
+>1 : 1
+>first : string
+>"ok" : "ok"
+>second : string
+>"error" : "error"
+
+over = { a: 1, b: 1, first: "ok", third: "error" }
+>over = { a: 1, b: 1, first: "ok", third: "error" } : { a: 1; b: 1; first: string; third: string; }
+>over : Overlapping
+>{ a: 1, b: 1, first: "ok", third: "error" } : { a: 1; b: 1; first: string; third: string; }
+>a : number
+>1 : 1
+>b : number
+>1 : 1
+>first : string
+>"ok" : "ok"
+>third : string
+>"error" : "error"
+
diff --git a/tests/cases/compiler/excessPropertyCheckWithUnions.ts b/tests/cases/compiler/excessPropertyCheckWithUnions.ts
new file mode 100644
index 0000000000000..9a7968fe5114e
--- /dev/null
+++ b/tests/cases/compiler/excessPropertyCheckWithUnions.ts
@@ -0,0 +1,50 @@
+type ADT = {
+    tag: "A",
+    a1: string
+} | {
+    tag: "D",
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+} | {
+    tag: "T",
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+wrong = { tag: "A", d20: 12 }
+wrong = { tag: "D" }
+
+type Ambiguous = {
+    tag: "A",
+    x: string
+} | {
+    tag: "A",
+    y: number
+} | {
+    tag: "B",
+    z: boolean
+} | {
+    tag: "C"
+}
+let amb: Ambiguous
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+amb = { tag: "A", y: 12 }
+amb = { tag: "A", x: "hi", y: 12 }
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+amb = { tag: "A", y: 12, extra: 12 }
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+amb = { tag: "A", z: true }
+
+type Overlapping =
+    | { a: 1, b: 1, first: string }
+    | { a: 2, second: string }
+    | { b: 3, third: string }
+let over: Overlapping
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+over = { a: 1, b: 1, first: "ok", third: "error" }