Generic types should never be considered empty objects

src/compiler/checker.ts

@@ -11386,7 +11386,7 @@ namespace ts {
         }
 
         function isEmptyObjectType(type: Type): boolean {
-            return type.flags & TypeFlags.Object ? isEmptyResolvedType(resolveStructuredTypeMembers(<ObjectType>type)) :
+            return type.flags & TypeFlags.Object ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(<ObjectType>type)) :
                 type.flags & TypeFlags.NonPrimitive ? true :
                 type.flags & TypeFlags.Union ? some((<UnionType>type).types, isEmptyObjectType) :
                 type.flags & TypeFlags.Intersection ? every((<UnionType>type).types, isEmptyObjectType) :
@@ -12361,7 +12361,7 @@ namespace ts {
                 }
                 else {
                     // An empty object type is related to any mapped type that includes a '?' modifier.
-                    if (isPartialMappedType(target) && !isGenericMappedType(source) && isEmptyObjectType(source)) {
+                    if (isPartialMappedType(target) && isEmptyObjectType(source)) {
                         return Ternary.True;
                     }
                     if (isGenericMappedType(target)) {

tests/baselines/reference/genericIsNeverEmptyObject.js

@@ -0,0 +1,41 @@
+//// [genericIsNeverEmptyObject.ts]
+// Repro from #29067
+
+function test<T extends { a: string }>(obj: T) {
+    let { a, ...rest } = obj;
+    return { ...rest, b: a };
+}
+
+let o1 = { a: 'hello', x: 42 };
+let o2: { b: string, x: number } = test(o1);
+
+
+//// [genericIsNeverEmptyObject.js]
+"use strict";
+// Repro from #29067
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+function test(obj) {
+    var a = obj.a, rest = __rest(obj, ["a"]);
+    return __assign({}, rest, { b: a });
+}
+var o1 = { a: 'hello', x: 42 };
+var o2 = test(o1);

tests/baselines/reference/genericIsNeverEmptyObject.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/genericIsNeverEmptyObject.ts ===
+// Repro from #29067
+
+function test<T extends { a: string }>(obj: T) {
+>test : Symbol(test, Decl(genericIsNeverEmptyObject.ts, 0, 0))
+>T : Symbol(T, Decl(genericIsNeverEmptyObject.ts, 2, 14))
+>a : Symbol(a, Decl(genericIsNeverEmptyObject.ts, 2, 25))
+>obj : Symbol(obj, Decl(genericIsNeverEmptyObject.ts, 2, 39))
+>T : Symbol(T, Decl(genericIsNeverEmptyObject.ts, 2, 14))
+
+    let { a, ...rest } = obj;
+>a : Symbol(a, Decl(genericIsNeverEmptyObject.ts, 3, 9))
+>rest : Symbol(rest, Decl(genericIsNeverEmptyObject.ts, 3, 12))
+>obj : Symbol(obj, Decl(genericIsNeverEmptyObject.ts, 2, 39))
+
+    return { ...rest, b: a };
+>rest : Symbol(rest, Decl(genericIsNeverEmptyObject.ts, 3, 12))
+>b : Symbol(b, Decl(genericIsNeverEmptyObject.ts, 4, 21))
+>a : Symbol(a, Decl(genericIsNeverEmptyObject.ts, 3, 9))
+}
+
+let o1 = { a: 'hello', x: 42 };
+>o1 : Symbol(o1, Decl(genericIsNeverEmptyObject.ts, 7, 3))
+>a : Symbol(a, Decl(genericIsNeverEmptyObject.ts, 7, 10))
+>x : Symbol(x, Decl(genericIsNeverEmptyObject.ts, 7, 22))
+
+let o2: { b: string, x: number } = test(o1);
+>o2 : Symbol(o2, Decl(genericIsNeverEmptyObject.ts, 8, 3))
+>b : Symbol(b, Decl(genericIsNeverEmptyObject.ts, 8, 9))
+>x : Symbol(x, Decl(genericIsNeverEmptyObject.ts, 8, 20))
+>test : Symbol(test, Decl(genericIsNeverEmptyObject.ts, 0, 0))
+>o1 : Symbol(o1, Decl(genericIsNeverEmptyObject.ts, 7, 3))
+

tests/baselines/reference/genericIsNeverEmptyObject.types

@@ -0,0 +1,36 @@
+=== tests/cases/compiler/genericIsNeverEmptyObject.ts ===
+// Repro from #29067
+
+function test<T extends { a: string }>(obj: T) {
+>test : <T extends { a: string; }>(obj: T) => Pick<T, Exclude<keyof T, "a">> & { b: string; }
+>a : string
+>obj : T
+
+    let { a, ...rest } = obj;
+>a : string
+>rest : Pick<T, Exclude<keyof T, "a">>
+>obj : T
+
+    return { ...rest, b: a };
+>{ ...rest, b: a } : Pick<T, Exclude<keyof T, "a">> & { b: string; }
+>rest : Pick<T, Exclude<keyof T, "a">>
+>b : string
+>a : string
+}
+
+let o1 = { a: 'hello', x: 42 };
+>o1 : { a: string; x: number; }
+>{ a: 'hello', x: 42 } : { a: string; x: number; }
+>a : string
+>'hello' : "hello"
+>x : number
+>42 : 42
+
+let o2: { b: string, x: number } = test(o1);
+>o2 : { b: string; x: number; }
+>b : string
+>x : number
+>test(o1) : Pick<{ a: string; x: number; }, "x"> & { b: string; }
+>test : <T extends { a: string; }>(obj: T) => Pick<T, Exclude<keyof T, "a">> & { b: string; }
+>o1 : { a: string; x: number; }
+

tests/cases/compiler/genericIsNeverEmptyObject.ts

@@ -0,0 +1,11 @@
+// @strict: true
+
+// Repro from #29067
+
+function test<T extends { a: string }>(obj: T) {
+    let { a, ...rest } = obj;
+    return { ...rest, b: a };
+}
+
+let o1 = { a: 'hello', x: 42 };
+let o2: { b: string, x: number } = test(o1);