Ability to type check factory constructed source files

[dsherret]

Suggestion

It would be nice to have the ability to type check factory constructed source files.

For example, say I create some ASTs like so, where params.module.body is some foreign AST that I'm converting to a tsc AST:

const sourceFile = ts.factory.createSourceFile(
    params.module.body.map(item => convertModuleItem(item)),
    ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), // side note... i'm unsure why this param exists
    ts.NodeFlags.None,
);
sourceFile.fileName = params.fileName;
sourceFile.text = params.fileText;
setRange(sourceFile, params.module); // my own function that sets the range

...it would be better to be able to use these source files without having to implement all the necessary hacks. For example, not having to do...

(sourceFile as any).parseDiagnostics = [];
(sourceFile as any).bindDiagnostics = [];

...along with figuring out how to set many more internal properties (ex. identifiers, pragmas, imports, etc... etc...).

🔍 Search Terms

type check transformed AST source file

✅ Viability Checklist

My suggestion meets these guidelines:

• [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
• [x] This wouldn't change the runtime behavior of existing JavaScript code
• [x] This could be implemented without emitting different JS based on the types of the expressions
• [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• [x] This feature would agree with the rest of TypeScript's Design Goals.

💻 Use Cases

• Ability to do AST transformations then feed that back through the type checker without having to print out the AST to a string then reparsing that string to an AST using the TS compiler.
• Ability to take a non-tsc AST representation of an AST and construct it to a tsc AST using the factory methods. This would be useful in Deno as it is already parsing an AST with swc and so it could pass that AST over to the TS compiler for type checking.

Viability?

I understand this is a huge ask and the main reason I'm opening this is to ask how viable it is?

I believe the type checker would need to be changed to sparingly consult the source file text or node ranges and some of the code in the parser that sets internal properties would need to be extracted out to support it being lazily computed in addition to when it's parsed. Additionally, factory methods would have to clear the appropriate internal properties on nodes when they're transformed so that they will be lazily computed in the future when the type checker goes to retrieve them. Anything else?

[ClixStudios]

Would love some feedback/advice on this particular suggestion, just some insight on it's viability would be appreciated - or if anyone's aware of any duplicate issues?