Combination of intersections/partials causes invalid nested object type to not report error

[dlane-stripe]

Bug Report

🔎 Search Terms

partial nested object type

🕗 Version & Regression Information

• This changed between versions 4.5.5 and 4.6.4. It reproduces in all versions since 4.6.4 (including nightly)

⏯ Playground Link

Playground link with relevant code

💻 Code

type OverridesInput = {
    someProp?: 'A' | 'B'
}

const foo: Partial<{something: any}> & {variables: {
    overrides?: OverridesInput;
} & Partial<{
    overrides?: OverridesInput;
}>} = {variables: {overrides: false}};

🙁 Actual behavior

There is no error on the overrides field in the object. Changing the type of foo slightly (removing one of the intersections) causes the error to appear correctly, but this unique combination of types produces no error. Does not matter what the contents of OverridesInput is, nor what the content inside the outer partial (currently {something: any}) is. Additionally, the following all produce the error correctly:

type OverridesInput = {
    someProp?: 'A' | 'B'
}

const foo: {variables: {
    overrides?: OverridesInput;
} & Partial<{
    overrides?: OverridesInput;
}>} = {variables: {overrides: false}};

type OverridesInput = {
    someProp?: 'A' | 'B'
}

const foo: Partial<{something: any}> & {variables: {
    overrides?: OverridesInput;
}} = {variables: {overrides: false}};

type OverridesInput = {
    someProp?: 'A' | 'B'
}

const foo: Partial<{something: any}> & {variables: Partial<{
    overrides?: OverridesInput;
}>} = {variables: {overrides: false}};

🙂 Expected behavior

There should be an error on the overrides field of the object since false is not assignable to OverridesInput | undefined.

[RyanCavanaugh]

type OverridesInput = {
    someProp?: 'A' | 'B'
}

const foo: Partial<{something: any}> & {variables: {
    overrides?: OverridesInput;
} & Partial<{
    overrides?: OverridesInput;
// @ts-expect-error
}>} = {variables: {overrides: false}};

[DanielRosenwasser]

This was a little easier for me to read.

interface Unrelated { _?: any }

// Identical but distinct types.
interface VariablesA { overrides?: OverridesInput; }
interface VariablesB { overrides?: OverridesInput; }

const foo: Unrelated & { variables: VariablesA & VariablesB } = {
    variables: {
        // Should be an error here:
        overrides: false
    }
};

I would've expected some weak type checking on this one.

[typescript-bot]

The change between release-4.4 and main occurred at 44e827b.

[RyanCavanaugh]

@ahejlsberg thoughts? This changed in #47738

[ahejlsberg]

The issue here is that when the target in a relation is an intersection, common property checks are only performed at the top level. For example:

type A1 = { x: { a?: string } };
type B1 = { x: { b?: string } };
type C1 = { x: { c: string } };

const ab1: A1 & B1 = {} as C1;  // No error

type A2 = { a?: string };
type B2 = { b?: string };
type C2 = { c: string };

const ab2: A2 & B2 = {} as C2;  // Error

We definitely should error in both of the examples above.