另外，值得注意的是，当编译器在错误信息中将 { b: any } & A 显示为 { b: any; } & { a: any; } & { c?: any; } 时，它得出了错误的结论。

declare function testA<Param extends A>(param: Param & A): Param;

和

declare function testA<Param extends A>(param: Param): Param;

有什么意图？

这是一个简化了实际代码中暴露bug的例子。这种模式在类型没有正确缩小的设计限制的通用函数中很有用：

type Animal = { type: 'dog'; forelegs: number } | { type: 'duck'; wings: number };

function calculateForelimbs<A extends Animal>(animal: A): A & { forelimbs: number } {
    return { ...animal, forelimbs: animal.type === 'dog' ? animal.forelegs : animal.wings };
    // won't work due to design limitation
}

可以通过向 animal 参数的类型添加 & Animal 来修复它：

function calculateForelimbsWorkable<A extends Animal>(animal: A & Animal): A & { forelimbs: number } {
    return { ...animal, forelimbs: animal.type === 'dog' ? animal.forelegs : animal.wings };
    // working like a charm
}

function createSuperAnimal(): Animal {
    const legsOrWings = 100500;
    const typeOfAnimal = Math.random() < 0.5 ? 'dog' : 'duck';

    return typeOfAnimal === 'dog'
        ? { type: typeOfAnimal, forelegs: legsOrWings }
        : { type: typeOfAnimal, wings: legsOrWings }
}

const superAnimalWithLimbsCalculated = calculateForelimbsWorkable(createSuperAnimal());

链接到Playground
如果我们使 Animal 类型更复杂：

type Animal = ({ type: 'dog'; forelegs: number } | { type: 'duck'; wings: number }) & { domesticated: boolean };

它仍然有效(链接到Playground)。
当我们决定让属性 domesticated 是可选的时候，结果发现代码是错误的：

type Animal = ({ type: 'dog'; forelegs: number } | { type: 'duck'; wings: number }) & { domesticated?: boolean };

链接到Playground
现在，当版本4.3.2带有改进的泛型上下文缩小功能已经发布时，它变得不那么实际了。现在我们可以跳过 & Animal 部分。
但是这个bug是一个bug。它可能会影响遗留代码，或者是更大问题的一个破损部分。

我找到了这个模式仍然有用的用例：

type A = ({ a: any } | { b: any }) & { c?: any };

declare function f<X extends A>(x: X): X

function testA1<Param extends A | undefined>(param: Param): Param {
    return param && f(param)
    // won't work even in typescript 4.3
};

function testA2<Param extends A | undefined>(param: Param & A): Param {
    return param && f(param)
    // working fine
};

declare const s1: A;

const a1 = testA2(s1); // still error

type B = ({ a: any } | { b: any }) & { c: any };

declare const s2: B;

const a2 = testA2(s2); // wrong type A | undefined, must be B

const a3 = testA1(s1); // A, but testA1 would not work on its own

const a4 = testA1(s2); // B, but testA1 would not work on its own

链接到Playground
在TypeScript 3.3.3333中运行良好：链接