Unexpected circular reference error TS7022

[jespertheend]

Bug Report

🔎 Search Terms

TS7022

🕗 Version & Regression Information

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

⏯ Playground Link

• JavaScript playground
• TypeScript playground

💻 Code

/** @template T */
class GenericClass {
	/**
	 * @param {(data: T) => void} handler
	 */
	setHandler(handler) {
	}
}

/** @type {GenericClass<typeof handlers>} */
const theClass = new GenericClass();
theClass.setHandler(() => {});

function emptyFunction() {}

const handlers = {
	thisWorksFine: emptyFunction,
	thisDoesnt: console.log,
};

🙁 Actual behavior

'theClass' is referenced directly or indirectly in its own type annotation, happens only in the JavaScript equivalent of this code and only if an external type is included in the handlers object.
Uncommenting thisDoesnt: console.log seems to remove the type errors for some reason.
theClass.setHandler(() => {}); also seems to be required for this

🙂 Expected behavior

No error, because there is no error in the TypeScript equivalent either.

[sandersn]

This error occurs in the equivalent TS program:

class GenericClass<T> {
    setHandler(handler: (date: T) => void) {
    }
}

const theClass: GenericClass<typeof handlers> = new GenericClass();
theClass.setHandler(() => {});

function emptyFunction() {}

const handlers = {
	thisDoesnt: console.log,
};

Here's a version that doesn't rely on console.log to fail, and is a module, so shouldn't have other things in scope:

export class GenericClass<T> {
    setHandler() {
    }
}

declare const theClass: GenericClass<typeof handlers>;
theClass.setHandler()
declare var con: {
    new(): unknown;
};
const handlers = {
	thisDoesnt: con,
};

[sandersn]

Here's the circularity. Everything is fine until checking the type of const handlers. Then this happens:

• getTypeOfSymbol(handlers)
• the type of handlers is derived from the type of its initialiser, part of which is con:
• checkExpression(con)
• after con's declared type is found, the compiler tries to narrow based on control flow:
• getFlowTypeOfReference(con, { new(): unknown })
• But this requires checking whether theClass.setHandler() has an asserts signature:
• getTypeAtFlowCall(theClass.setHandler())
• getEffectsSignature(theClass.setHandler())
• Which of course means we need the type of theClass, and then typeof handlers, and then handlers:
• getTypeOfSymbol(theClass)
• getTypeFromTypeQueryNode(typeof handlers)
• getTypeOfSymbol(handlers)

Here's a variation of the original program where the assertion should actually change the type of con:

export class C<T, U> {
    m(t: T, u: U): asserts u is U & { extra: "cool" } {
        if ((t as any).extra !== "cool") throw new Error("not cool");
    }
}

declare const theClass: C<typeof handlers, { new(): unknown }>;
declare var con: {
    new(): unknown;
};
theClass.m({ thisDoesnt: "matter", extra: "cool" });
const handlers = {
	thisDoesnt: con,
};

If I could figure out a way for con and handlers to be the same thing, then it would be a true circularity, although the current example still should be determinable by a sufficiently smart compiler (not present-day Typescript).