Array filter() by element constructor returns never[] about typescript HOT 12 CLOSED

Why are we calling this “5.2”?

from typescript.

Related #16035

from typescript.

Seems to me the real issue is this:

class GenericClass {
    constructor(public value: string) { }
}

class ConcreteClass extends GenericClass {
    constructor(value: string) {
        super(`Concrete: ${value}`);
    }
}

function foo(obj: GenericClass) {
    if (obj.constructor === ConcreteClass) {
        obj;  // never, Wat?
    }
}

It's obviously possible for obj.constructor to be ConcreteClass since that class is derived from GenericClass. The error that this issue reports is simply a follow-on effect of the incorrect narrowing that gets picked up in an inferred type predicate.

from typescript.

Changed in 5.2 5.5 so probably a result of automatic type predicate inference

from typescript.

The return type of filter callback (element) => element.constructor === ConcreteClass is inferred as element is never in 5.5.2 because of #57465. I would suggest using (element) => element instanceof ConcreteClass instead.

from typescript.

Why are we calling this “5.2”?

Oops, typo and/or me being in too much of a rush. Fixed now.

from typescript.

I would suggest using (element) => element instanceof ConcreteClass instead.

Yes, I agree this works and is more idiomatic. I will change this in my code to fix the problem. I wanted to report it in case other projects unexpectedly break while trying to do a minor bump. I'm not sure if 5.5.2 fixes a long standing bug or not, but regardless it was a surprise to have a broken build after this minor upgrade. Thanks for your work on it 🙏

from typescript.

@whzx5byb Thats weird though because #16035 suggests this condition doesn’t narrow

from typescript.

@fatcerberus Actually the .constructor narrowing works only when the target is a union type and it must be compared using === (or ==, but not for switch clause) operator. I'm very surprised that it even works for the switch (true) pattern as long as there is a === comparison!

class A {
  a!: number;
}

class B {
  b!: number;
}


function fn(input: A | B) {
  switch (input.constructor) {
    case A:
      input.a // <- not work
  }

  switch (true) {
    case input.constructor === A:
      input.a; // work!?
  }
}

But anyway, in the OP's case the narrowing target is not a union type, and .constructor === comparison will always narrow it to never.

from typescript.

It goes all the way back to #32774 that implemented "constructor type guards". There is no logic to deal with derived classes.

from typescript.

#32774 that implemented "constructor type guards"

Wait, why is #16035 still open then?

from typescript.

This issue has been marked as "Design Limitation" and has seen no recent activity. It has been automatically closed for house-keeping purposes.

from typescript.