An intermediate named reference is required to infer the type of object field indexed by a literal type

[castarco]

TypeScript Version(s): 3.9.3, next

Search Terms: type inference, indexed, union type, literal type

Code
This example works as intended, I'll comment the next one with a small tweak (although the temporal order was the reverse for me).

type FunnyType = {
  fieldA?: string[] | { [key: string]: string[] }
  fieldB?: string[] | { [key: string]: string[] }
}

function getNormalizedField(
  fieldName: 'fieldA' | 'fieldB',
  funnyObject: FunnyType,
  envName: string | undefined
) {
  let field: string[] = []
  const fieldOrigin = funnyObject[fieldName]
  if (fieldOrigin) {
    if (fieldOrigin instanceof Array) {
      field = fieldOrigin
    } else if (fieldOrigin instanceof Object) {
      if (!envName) {
        throw new Error('Environment name not provided, unable to select')
      }
      field = fieldOrigin[envName] ?? []
    }
  }
  return field
}

But this one, without the intermediate named object fieldOrigin, fails at line 14 (field = funnyObject[fieldName]), even if the assigned value is the same. When using an intermediate named object Typescript is able to narrow down its type, but for some reason is not able to do the same when the object reference is a little bit more "complicated" ( variable[index] ).

type FunnyType = {
  fieldA?: string[] | { [key: string]: string[] }
  fieldB?: string[] | { [key: string]: string[] }
}

function getNormalizedField(
  fieldName: 'fieldA' | 'fieldB',
  funnyObject: FunnyType,
  envName: string | undefined
) {
  let field: string[] = []
  if (funnyObject[fieldName]) {
    if (funnyObject[fieldName] instanceof Array) {
      field = funnyObject[fieldName]
    } else if (funnyObject[fieldName] instanceof Object) {
      if (!envName) {
        throw new Error('Environment name not provided, unable to select')
      }
      field = funnyObject[fieldName][envName] ?? []
    }
  }
  return field
}

Expected behavior:
Typescript should be able to narrow down the type of "simple" reference (with shape variable[index], where index belongs to a well identified finite set of literal values (I think the formal name is "literal type"?), and the types for each index of variable are also well known.

Actual behavior:
Typescript is not able to narrow down the type of such "simple" reference, and it needs some extra help, by creating an intermediate named reference.

Playground Link:
Playground Link

Related Issues:

• Type inference in index type assignment is skipped #37874 seems related, but I would say is not the same problem.
• Type is not inferred in an if branch of a user-defined type guard when object is used for destructuring #38700

[MartinJohns]

Duplicate #10530. Type narrowing does not occur for indexed access forms e[k] where k is not a literal.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.