Types with optional props get implicit index signatures that cannot be made explicit

🔎 Search Terms

implicit index signatures, explicit index signatures, optional partial undefined,

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about index signatures and undefined

⏯ Playground Link

Playground link

💻 Code

// @strict: true
// @exactOptionalPropertyTypes: false
// @noUncheckedIndexedAccess: false

type ObjImplicit = {
    a?: string | undefined,
    b: string
};
type Idx = { [k: string]: string }
declare const o: ObjImplicit;
const i: Idx = o; // allowed because A has implicit index signature

type ObjExplicit = {
    a?: string | undefined, // error! not allowed
    //~ <-- Property 'a' of type 'string | undefined' is not assignable to 'string' index type 'string'.
    b: string,
    [k: string]: string
}

🙁 Actual behavior

{ a?: string | undefined } can implicitly have the index signature {[k: string]: string} but cannot explicitly have such an index signature

🙂 Expected behavior

I think I expected the implicit index signature to fail?

Additional information about the issue

Without --exactOptionalPropertyTypes, {a?: string} and {a?: string | undefined} are the same type. I figured that would mean both implicitly and explicitly adding index signatures would either require or not require undefined.

We also have the situation where Partial<{[k: string]: string}> becomes {[k: string]: string | undefined} instead of {[k: string]: string}, which makes me lean toward "require undefined", for consistency. Currently the discrepancy leads to questions like this one.

Anyway, I expect this to not be a bug, but intended behavior that flew under my radar and which I cannot see explicitly documented anywhere. Mostly I just want to understand this behavior so I can explain it when people ask questions like the one linked above.

Inizia con il TypeScript Playground collegato e confronta gli esempi di firme di indice implicite ed esplicita con le opzioni del compilatore mostrate. Segui il comportamento rilevante del controllo dei tipi per determinare la regola prevista, quindi documenta tale regola e la relazione con exactOptionalPropertyTypes e Partial; il lavoro è completato quando la discrepanza è spiegata chiaramente.