TypeScript ignore expression `if (object instanceof SomeClass)` inside `for(){}` and inside `()=>{}`.

[KostyaTretyak]

TypeScript Version: 2.1.4

Code

class ClassA
{
  propA: any;
}

class ClassB
{
  propB: any;
}

function fn( arr: Array<ClassA | ClassB> )
{
  for( let element of arr )
  {
    if( element instanceof ClassA )
    {
      element.propA = true; // Work as expected

      () =>
      {
        element.propA; // Unexpected error
      }
    }
  }
}

Expected behavior:

Works without error

Actual behavior:

Throw error:

Property 'propA' does not exist on type 'ClassA | ClassB'.
Property 'propA' does not exist on type 'ClassB'.

When I remove the loop for(){}. Works as expected:

class ClassA
{
  propA: any;
}

class ClassB
{
  propB: any;
}

function fn( element: ClassA | ClassB )
{
  if( element instanceof ClassA )
  {
    element.propA = true; // Work as expected

    () =>
    {
      element.propA; // Work as expected
    }
  }
}

[aluanhaddad]

for (let element of arr) {
  if (element instanceof ClassA) {
    element.propA = true;

   () => {
      element.propA;
    }
  }
}

Your inner function is closing over a mutable binding that is scoped outside the if block and is thus not always going to be an instance of ClassA.

To make this work, use a const binding:

function fn(arr: (ClassA | ClassB)[]) {
  for(const element of arr) {

[KostyaTretyak]

@aluanhaddad, thanks for the answer.

Mutable - possible, but in fact this code is no mutation. TypeScript checks so deeply?

[aluanhaddad]

I think the question comes down to scope of the variable. A constant binding could not be scoped to the for of declarator.

[aluanhaddad]

Also, CFA doesn't track what happens inside of closures to make inferences about types in the outer scope.

My recommendation, and this is just my personal opinion, is that all bindings should be const unless they need to be let or var. I think it makes code a lot easier to read and is real boon to the maintenance programmer.

[KostyaTretyak]

@aluanhaddad, thank you.