instanceof type guard fails with a static `toString` method

[chharvey]

TypeScript Version: 3.0.3
Options: --strict --noImplicitAny --noImplicitThis --noImplicitReturns --target="ES2017" --module="CommonJS"

Search Terms: instanceof type guard class "toString"

Code:

declare class Thing { static toString(thing: any): string; } // <!-- here’s the problem
declare class Person extends Thing { name: string; }
declare class Robot extends Thing { serial: number; }

function test(smart_thing: Person|Robot): number {
	if (smart_thing instanceof Robot) {
		return smart_thing.serial // typeof `smart_thing` is Person|Robot,
		                          // and getting `.serial` fails
	} else return 0
}

Expected behavior:

The type of smart_thing should be narrowed to Robot.

Actual behavior:

The type of smart_thing has not been narrowed from Person | Robot.

When the static method Thing.toString is renamed or removed, or its parameter is deleted, the problem goes away.

Playground Link:

TypeScript Playground

What is the code in Person.class.ts and Employee.class.ts?

[chharvey]

UPDATE

ignore this comment; it was from a different problem

---

@Andy-MS typical class code. in this reduced example, it could be as simple as this:

// Person.class.ts
export default class Person {
	constructor() {}
}

// Employee.class.ts
import Person from './Person.class'
export default class Employee extends Person {
	id: number;
	constructor(id: number) {
		super()
		this.id = id
	}
}

That reduced example is working when I try it.

[chharvey]

@Andy-MS Ok so I think I found part of the problem. It weirdly involves a static toString method that takes a parameter, that inherits into each member of the union. It has nothing to do with imports. I've updated my code in the OP and the Playground.

[thw0rted]

Hey, any movement on this? I just hit the same issue and it took me quite a while to figure out. I had an separate fooToString method that I moved into Foo as a static toString and suddenly all my type guards broke.

I couldn't get the OP playground link to work for me, but you can paste this in to see what I mean:

class A {
    public foo: string;
}

class B implements A {
    public foo: string;
    public bar: number;

    static toString(b: B) { return b.bar; }
}

class C implements A {
    public foo: string;
    public baz: boolean;

    static toString2(c: C) { return c.baz; } 
}

let x: A;
if (x instanceof B) { console.log(x.bar); }  // .bar is an error because X is still typed as A, not B
if (x instanceof C) { console.log(x.baz); }  // .baz works fine

Note that it's not only an issue when the superclass has a static toString, it's also a problem when one of the subclasses (the one that you're trying to narrow to, if that makes sense) has it.

[jakebailey]

I'm looking at old bugs for ones that appear to be fixed; all of the snippets in this issue appear to have been fixed from at least 3.3 and up (maybe even older).