A series of nested loops, undefined and in checks results in incorrect implicit any

[frigus02]

Bug Report

A series of nested loops, undefined and in checks results in incorrect implicit any.

I don't know what is really causing this. It seems this might be a weird edge case where type inference fails?

🔎 Search Terms

noImplicitAny, inference

🕗 Version & Regression Information

This changed between versions 4.3.5 and 4.4.2

⏯ Playground Link

Playground link with relevant code

💻 Code

interface MyObj { id?: string; }
declare var objects: MyObj[]|undefined;

if (objects) {
  for (const _ of []) {
    const map: {[key:string]: string|undefined} = {};

    for (const obj of objects) {
      //       ~~~ 'obj' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.(7022)
      const id = obj.id!;
      //    ~~ 'id' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.(7022)
      if (id in map) {
        console.log(id);
      }
    }
  }
}

🙁 Actual behavior

In version 4.4.2 the above code fails to compile with the 2 errors.

Any of the following changes cause it compile without errors:

• Remove |undefined from the objects type.
• Remove the outer for (const _ of []) loop
• Remove if (id in map)
• Add a type annotation to the id variable: const id: string = obj.id!

🙂 Expected behavior

The code should compile without errors as it did in version 4.3.5.

[frigus02]

I have another example. Not entirely sure it's the same but it seems related to me:

function doSth(items: unknown[], indexes?: number[]) {
    if (!indexes) {
        return;
    }

    for (let i = 0; i < indexes.length; i++) {
        const index = indexes[i];
        //    ~~~~~ 'index' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.(7022)
        if (index in items) {}
    }
}

Playground link

Again we can get rid of the error a small adjustment. Any of those work:

• Make indexes not undefined (remove the ? from the parameter)
• Add a type annotation to index: const index: number = ...
• Remove the line if (index in items) {}

[frigus02]

We're currently upgrading to TypeScript 4.7 (beta) and that caused another issue that looks very similar to this one.

interface Method {
  httpMethod: string;
}

interface Resource {
  methods?: {[index: string]: Method};
}

function extract(resource: Resource): void {
  const store: Record<string, unknown> = {};
  if (resource.methods) {
    for (const methodName of Object.keys(resource.methods)) {
      const methodSpec = resource.methods[methodName];
      //    ^^^^^^^^^^  'methodSpec' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.(7022)
      const verb = methodSpec.httpMethod.toLowerCase();
      store[verb] = {};
    }
  }
}

Playground (4.6.2) --> all fine, no error

Playground (nightly, 4.7.0-dev.20220422) --> error as included in the snippet above