Type narrowing does not properly narrow type of generic class instance

[caffeinewriter]

Bug Report

🔎 Search Terms

code path, type narrowing

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about type narrowing

⏯ Playground Link

TypeScript Nightly
TypeScript v4.5.4
TypeScript v3.3.3 (no private fields)

💻 Code

type GenericClass = new (...args: any) => any;

export default class SingletonFactory<T extends GenericClass> {
    readonly #instanceClass: T;
    #instance?: InstanceType<T>;
    constructor(instanceClass: T) {
        this.#instanceClass = instanceClass;
    }
    getInstance(options?: ConstructorParameters<T>): InstanceType<T> {
        if (this.#instance === undefined) {
            if (!options) {
                // Error if both instance and options are undefined
                throw new Error('No instance found, and no options provided');
            }
            // Create new instance if not defined, and options are provided
            this.#instance = new this.#instanceClass(options);
            return this.#instance; // Error: Type 'InstanceType<T> | undefined' is not assignable to type 'InstanceType<T>'.
        }
        return this.#instance;
    }
}

🙁 Actual behavior

After creating a new instance of this.#instanceClass, TypeScript still reports the type as possibly undefined.

🙂 Expected behavior

After creating a new instance and assigning it to this.#instance, the type of this.#instance should narrow to only InstanceType<T>. A workaround can be achieved by assigning the new instance to an intermediary variable, and then returning the intermediary variable instead.

Example playground of workaround

Additionally, even though the type of the property is InstanceType<T> | undefined, other similar situations properly narrow the code path. I've created an example using string | undefined here for comparison.

Thanks!

[RyanCavanaugh]

this.#instance = new this.#instanceClass(options);

The RHS of this line is any because the constructor types is reduced to its constraint, so no narrowing occurs.

It'd be better to define the class this way

export default class SingletonFactory<Class, Params> {
    readonly #instanceClass: { new(args: Params): Class };
    #instance!: Class;
    constructor(instanceClass: { new(args: Params): Class }) {
        this.#instanceClass = instanceClass;
    }
    getInstance(options?: Params): Class {
        if (this.#instance === undefined) {
            if (!options) {
                throw new Error('No instance found, and no options provided')
            }
            this.#instance = new this.#instanceClass(options);
            // Should not be undefined, as it was instantiated immediately above
            // Removing this line and allowing the final return produces the same error
            return this.#instance;
        }
        return this.#instance;
    }
}

or just not declare #instance optional, assuming it's reliably initialized in this codepath.

[github-actions]

This issue has been marked as 'Not a Defect' and has seen no recent activity. It has been automatically closed for house-keeping purposes.