Add createProgram to API - #63950
Conversation
createProgram to API
| } | ||
|
|
||
| projectCollectionBuilder.DidChangeCustomConfigFileName(logger.Fork("DidChangeCustomConfigFileName")) | ||
| if change.compilerOptionsForInferredProjects != nil && projectCollectionBuilder.inferredProject.Value() != nil { |
There was a problem hiding this comment.
Drive-by fix.
| inferred.Program = project.Program | ||
| inferred.ProgramLastUpdate = project.ProgramLastUpdate | ||
| inferred.host = project.host | ||
| inferred.checkerPool = project.checkerPool |
There was a problem hiding this comment.
This feels a bit awkward to me, but I'm not sure if there's a better way to do this whole thing.
There was a problem hiding this comment.
Pull request overview
Adds a snapshot-backed createProgram API supporting isolated programs and incremental updates.
Changes:
- Adds sync/async client APIs and protocol types.
- Builds synthetic projects with roots, options, references, diagnostics, and file changes.
- Adds comprehensive API and project tests.
Reviewed changes
Copilot reviewed 20 out of 20 changed files in this pull request and generated 3 comments.
Show a summary per file
| File | Description |
|---|---|
tsc/internal/tsoptions/parsedcommandline.go |
Adds project references to parsed command lines. |
tsc/internal/tsoptions/contentmappers_test.go |
Updates constructor usage. |
tsc/internal/tsoptions/commandlineparser.go |
Updates constructor usage. |
tsc/internal/project/snapshot.go |
Adds isolated program snapshot cloning. |
tsc/internal/project/projectcollectionbuilder.go |
Supports synthetic inferred-project updates. |
tsc/internal/project/project.go |
Adds reference-aware inferred projects and reuse. |
tsc/internal/project/project_test.go |
Tests inferred compiler-option updates. |
tsc/internal/project/api.go |
Exposes server-side program creation. |
tsc/internal/execute/tsc/emit_test.go |
Updates constructor usage. |
tsc/internal/compiler/projectreferenceparser.go |
Supports reference roots without config files. |
tsc/internal/compiler/projectreferencefilemapper.go |
Handles synthetic root configurations. |
tsc/internal/ast/diagnostic.go |
Adds text-based diagnostic construction. |
tsc/internal/api/session.go |
Handles createProgram requests. |
tsc/internal/api/session_createprogram_test.go |
Tests server-side creation and reuse. |
tsc/internal/api/proto.go |
Defines protocol and diagnostic conversion. |
packages/typescript/test/sync/api.test.ts |
Tests the synchronous API. |
packages/typescript/test/async/api.test.ts |
Tests the asynchronous API. |
packages/typescript/src/api/sync/api.ts |
Adds synchronous createProgram and disposal. |
packages/typescript/src/api/proto.generated.ts |
Adds generated protocol declarations. |
packages/typescript/src/api/async/api.ts |
Adds asynchronous createProgram and disposal. |
💡 Add a code-review agent skill for context-aware, tailored reviews. Learn more in the docs.
| func (d *DiagnosticResponse) ToDiagnostic() *ast.Diagnostic { | ||
| return ast.NewDiagnosticFromText( | ||
| nil, | ||
| core.NewTextRange(d.Pos, d.End), |
There was a problem hiding this comment.
Unsure if this is worth resolving or how. I think we could try getting the source file on the server side, but there's no guarantee it'll succeed and it's the same that produced the diagnostics in the first place.
This PR adds
createProgramto the API (part of #63875).The API is similar to what we had in Strada, where we take root file names, compiler options, and optionally project references and config file parsing diagnostics, and return a program.
It also optionally takes an
oldProgramand file changes to apply to this old program to construct a new program.Because this API allows you to evolve a program over time by applying changes, its implementation is based on snapshots. So each program returned by this API has a corresponding snapshot to back it. But the process for creating such a snapshot is a little different from the usual: we want this snapshot to back only the one program we're creating. So there's a new
snapshot.cloneForProgramjust for that. The way it works is that we create a new synthetic inferred project during clone that will contain the root file names and compiler options that were provided viacreateProgram.The
oldProgramdoesn't necessarily have to be created bycreateProgrameither, but it does need to be backed by a server-side snapshot (this may need to change in the future: I'm not sure this would work for the programs created by the upcoming solution builder API).If an
oldProgramisn't provided, we rely on the updated server snapshot as a base for creating the program.Waiting on #63935 to fix the diagnostics conversion.