"Variable is used before being assigned" even though it is assigned

TypeScript Version: 2.6.1

Code

type Patch<T> = {
  [P in keyof T]?: Patch<T[P]> | ((value: T[P]) => T[P])
}

function applyPatch<T extends object, K extends keyof T>(target: T, patch: Patch<T>): T {
  (Object.keys(patch) as K[]).forEach(key => {
    const patchValue = patch[key];
    target[key] = typeof patchValue == "object" && !Array.isArray(patchValue)
      ? applyPatch(target[key] || {}, patchValue)
      : typeof patchValue == "function" // Error: Variable 'patchValue' is used before being assigned.
        ? patchValue(target[key])
        : patchValue; // Error: Variable 'patchValue' is used before being assigned.
  });
  return target;
}

Expected behavior: No error

Actual behavior:

Error: Variable ‘patchValue’ is used before being assigned.

It goes away if I assert patchValue as non-null:

const patchValue = patch[key]!

[patrickroberts]

I also have this issue with this code:

let resolver;
new Promise(resolve => (resolver = resolve));
console.log(resolver);

That particular case is a valid warning. Even though we know the executor passed to the Promise constructor is synchronous, TypeScript can’t statically determine that it is and assumes that it is asynchronous. If it were hypothetically asynchronous, the variable would indeed be used before being assigned. You can use an assertion ! to hint to TypeScript that you know it’s assigned at the point of usage:

let resolver: (value?: unknown) => void;
new Promise(resolve => (resolver = resolve));
console.log(resolver!);

Try it on TS Playground

[andy-ms]

I don’t know how hard that would be, but I’ve seen issues similar to this come up in the past and be turned down.