From 6bb2373d84304cb316324121dac7448a4066027e Mon Sep 17 00:00:00 2001 From: Titian Cernicova-Dragomir Date: Tue, 7 Jul 2026 17:31:19 +0100 Subject: [PATCH 1/2] Add batched version for several API functions. --- _packages/native-preview/src/api/async/api.ts | 87 +++++++++-- _packages/native-preview/src/api/sync/api.ts | 87 +++++++++-- .../native-preview/test/async/api.test.ts | 137 ++++++++++++++++++ .../native-preview/test/sync/api.test.ts | 137 ++++++++++++++++++ internal/api/proto.go | 136 ++++++++++------- internal/api/session.go | 136 +++++++++++++++++ 6 files changed, 642 insertions(+), 78 deletions(-) diff --git a/_packages/native-preview/src/api/async/api.ts b/_packages/native-preview/src/api/async/api.ts index 77e19bf93f9..6c3945e3a5d 100644 --- a/_packages/native-preview/src/api/async/api.ts +++ b/_packages/native-preview/src/api/async/api.ts @@ -1156,11 +1156,24 @@ export class Checker { * declared type cannot be determined the checker yields the error type (use * {@link Type.isErrorType} to detect it). */ - async getDeclaredTypeOfSymbol(symbol: Symbol): Promise { + async getDeclaredTypeOfSymbol(symbol: Symbol): Promise; + async getDeclaredTypeOfSymbol(symbols: readonly Symbol[]): Promise; + async getDeclaredTypeOfSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { + if (Array.isArray(symbolOrSymbols)) { + const data = await this.client.apiRequest("getDeclaredTypesOfSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map((d, i) => { + return this.objectRegistry.getOrCreateType(d); + }); + } + const sym = symbolOrSymbols as Symbol; const data = await this.client.apiRequest("getDeclaredTypeOfSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return this.objectRegistry.getOrCreateType(data); } @@ -1632,20 +1645,45 @@ export class Checker { * an unresolved alias the checker yields the unknown symbol (use * {@link Checker.isUnknownSymbol} to detect it). */ - async getAliasedSymbol(symbol: Symbol): Promise { + async getAliasedSymbol(symbol: Symbol): Promise; + async getAliasedSymbol(symbols: readonly Symbol[]): Promise; + async getAliasedSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { + if (Array.isArray(symbolOrSymbols)) { + const data = await this.client.apiRequest("getAliasedSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map((d, i) => { + if (!d) throw new Error(`getAliasedSymbol returned no symbol for symbol ${symbolOrSymbols[i].id}`); + return this.objectRegistry.getOrCreateSymbol(d); + }); + } + const sym = symbolOrSymbols as Symbol; const data = await this.client.apiRequest("getAliasedSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return this.objectRegistry.getOrCreateSymbol(data); } - async getImmediateAliasedSymbol(symbol: Symbol): Promise { + async getImmediateAliasedSymbol(symbol: Symbol): Promise; + async getImmediateAliasedSymbol(symbols: readonly Symbol[]): Promise<(Symbol | undefined)[]>; + async getImmediateAliasedSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { + if (Array.isArray(symbolOrSymbols)) { + const data = await this.client.apiRequest<(SymbolResponse | null)[]>("getImmediateAliasedSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined); + } + const sym = symbolOrSymbols as Symbol; const data = await this.client.apiRequest("getImmediateAliasedSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined; } @@ -1706,21 +1744,46 @@ export class Checker { return signature.id === (await this.getWellKnownSignatures()).unknown; } - async getExportsOfModule(symbol: Symbol): Promise { - const data = await this.client.apiRequest("getExportsOfModule", { + async getExportsOfModule(symbol: Symbol): Promise; + async getExportsOfModule(symbols: readonly Symbol[]): Promise; + async getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { + if (Array.isArray(symbolOrSymbols)) { + const data = await this.client.apiRequest("getExportsOfModules", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map(d => d ? d.map(s => this.objectRegistry.getOrCreateSymbol(s)) : []); + } + const sym = symbolOrSymbols as Symbol; + const data = await this.client.apiRequest("getExportsOfModule", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return data ? data.map(d => this.objectRegistry.getOrCreateSymbol(d)) : []; } - async getMemberInModuleExports(symbol: Symbol, name: string): Promise { + async getMemberInModuleExports(symbol: Symbol, name: string): Promise; + async getMemberInModuleExports(requests: readonly { symbol: Symbol; name: string; }[]): Promise<(Symbol | undefined)[]>; + async getMemberInModuleExports( + symbolOrRequests: Symbol | readonly { symbol: Symbol; name: string; }[], + name?: string, + ): Promise { + if (Array.isArray(symbolOrRequests)) { + const data = await this.client.apiRequest<(SymbolResponse | null)[]>("getMembersInModuleExports", { + snapshot: this.snapshotId, + project: this.project.id, + requests: symbolOrRequests.map(r => ({ symbol: r.symbol.id, name: r.name })), + }); + return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined); + } + const sym = symbolOrRequests as Symbol; const data = await this.client.apiRequest("getMemberInModuleExports", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, - name, + symbol: sym.id, + name: name!, }); return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined; } diff --git a/_packages/native-preview/src/api/sync/api.ts b/_packages/native-preview/src/api/sync/api.ts index 447656f2a57..3985ecb339b 100644 --- a/_packages/native-preview/src/api/sync/api.ts +++ b/_packages/native-preview/src/api/sync/api.ts @@ -1164,11 +1164,24 @@ export class Checker { * declared type cannot be determined the checker yields the error type (use * {@link Type.isErrorType} to detect it). */ - getDeclaredTypeOfSymbol(symbol: Symbol): Type { + getDeclaredTypeOfSymbol(symbol: Symbol): Type; + getDeclaredTypeOfSymbol(symbols: readonly Symbol[]): Type[]; + getDeclaredTypeOfSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Type | Type[] { + if (Array.isArray(symbolOrSymbols)) { + const data = this.client.apiRequest("getDeclaredTypesOfSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map((d, i) => { + return this.objectRegistry.getOrCreateType(d); + }); + } + const sym = symbolOrSymbols as Symbol; const data = this.client.apiRequest("getDeclaredTypeOfSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return this.objectRegistry.getOrCreateType(data); } @@ -1640,20 +1653,45 @@ export class Checker { * an unresolved alias the checker yields the unknown symbol (use * {@link Checker.isUnknownSymbol} to detect it). */ - getAliasedSymbol(symbol: Symbol): Symbol { + getAliasedSymbol(symbol: Symbol): Symbol; + getAliasedSymbol(symbols: readonly Symbol[]): Symbol[]; + getAliasedSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Symbol | Symbol[] { + if (Array.isArray(symbolOrSymbols)) { + const data = this.client.apiRequest("getAliasedSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map((d, i) => { + if (!d) throw new Error(`getAliasedSymbol returned no symbol for symbol ${symbolOrSymbols[i].id}`); + return this.objectRegistry.getOrCreateSymbol(d); + }); + } + const sym = symbolOrSymbols as Symbol; const data = this.client.apiRequest("getAliasedSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return this.objectRegistry.getOrCreateSymbol(data); } - getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined { + getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined; + getImmediateAliasedSymbol(symbols: readonly Symbol[]): (Symbol | undefined)[]; + getImmediateAliasedSymbol(symbolOrSymbols: Symbol | readonly Symbol[]): Symbol | (Symbol | undefined)[] | undefined { + if (Array.isArray(symbolOrSymbols)) { + const data = this.client.apiRequest<(SymbolResponse | null)[]>("getImmediateAliasedSymbols", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined); + } + const sym = symbolOrSymbols as Symbol; const data = this.client.apiRequest("getImmediateAliasedSymbol", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined; } @@ -1714,21 +1752,46 @@ export class Checker { return signature.id === (this.getWellKnownSignatures()).unknown; } - getExportsOfModule(symbol: Symbol): readonly Symbol[] { - const data = this.client.apiRequest("getExportsOfModule", { + getExportsOfModule(symbol: Symbol): readonly Symbol[]; + getExportsOfModule(symbols: readonly Symbol[]): readonly (readonly Symbol[])[]; + getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): readonly Symbol[] | readonly (readonly Symbol[])[] { + if (Array.isArray(symbolOrSymbols)) { + const data = this.client.apiRequest("getExportsOfModules", { + snapshot: this.snapshotId, + project: this.project.id, + symbols: symbolOrSymbols.map(s => s.id), + }); + return data.map(d => d ? d.map(s => this.objectRegistry.getOrCreateSymbol(s)) : []); + } + const sym = symbolOrSymbols as Symbol; + const data = this.client.apiRequest("getExportsOfModule", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, + symbol: sym.id, }); return data ? data.map(d => this.objectRegistry.getOrCreateSymbol(d)) : []; } - getMemberInModuleExports(symbol: Symbol, name: string): Symbol | undefined { + getMemberInModuleExports(symbol: Symbol, name: string): Symbol | undefined; + getMemberInModuleExports(requests: readonly { symbol: Symbol; name: string; }[]): (Symbol | undefined)[]; + getMemberInModuleExports( + symbolOrRequests: Symbol | readonly { symbol: Symbol; name: string; }[], + name?: string, + ): Symbol | (Symbol | undefined)[] | undefined { + if (Array.isArray(symbolOrRequests)) { + const data = this.client.apiRequest<(SymbolResponse | null)[]>("getMembersInModuleExports", { + snapshot: this.snapshotId, + project: this.project.id, + requests: symbolOrRequests.map(r => ({ symbol: r.symbol.id, name: r.name })), + }); + return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined); + } + const sym = symbolOrRequests as Symbol; const data = this.client.apiRequest("getMemberInModuleExports", { snapshot: this.snapshotId, project: this.project.id, - symbol: symbol.id, - name, + symbol: sym.id, + name: name!, }); return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined; } diff --git a/_packages/native-preview/test/async/api.test.ts b/_packages/native-preview/test/async/api.test.ts index e084ebc2731..ad382354016 100644 --- a/_packages/native-preview/test/async/api.test.ts +++ b/_packages/native-preview/test/async/api.test.ts @@ -3839,6 +3839,143 @@ export * from "./inner"; }); }); +describe("Checker - batched methods", () => { + test("getImmediateAliasedSymbol resolves multiple aliases", async () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const a = 1;`, + "/src/b.ts": `export const b = 2;`, + "/src/main.ts": `import { a } from "./a";\nimport { b } from "./b";\nexport const usage = a + b;`, + }); + try { + const snapshot = await api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const posA = `import { a } from "./a";`.indexOf("a }"); + const posB = `import { a } from "./a";\nimport { b } from "./b";`.indexOf("b }"); + const symA = await project.checker.getSymbolAtPosition("/src/main.ts", posA); + const symB = await project.checker.getSymbolAtPosition("/src/main.ts", posB); + assert.ok(symA); + assert.ok(symB); + const results = await project.checker.getImmediateAliasedSymbol([symA, symB]); + assert.equal(results.length, 2); + assert.equal(results[0]?.name, "a"); + assert.equal(results[1]?.name, "b"); + } + finally { + await api.close(); + } + }); + + test("getAliasedSymbol resolves multiple import aliases", async () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const a = 1;`, + "/src/b.ts": `export const b = 2;`, + "/src/main.ts": `import { a } from "./a";\nimport { b } from "./b";`, + }); + try { + const snapshot = await api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const posA = `import { a } from "./a";`.indexOf("a }"); + const posB = `import { a } from "./a";\nimport { b } from "./b";`.indexOf("b }"); + const symA = await project.checker.getSymbolAtPosition("/src/main.ts", posA); + const symB = await project.checker.getSymbolAtPosition("/src/main.ts", posB); + assert.ok(symA); + assert.ok(symB); + const results = await project.checker.getAliasedSymbol([symA, symB]); + assert.equal(results.length, 2); + assert.equal(results[0].name, "a"); + assert.ok(!(results[0].flags & SymbolFlags.Alias)); + assert.equal(results[1].name, "b"); + assert.ok(!(results[1].flags & SymbolFlags.Alias)); + } + finally { + await api.close(); + } + }); + + test("getExportsOfModule returns exports for multiple modules", async () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const alpha = 1;`, + "/src/b.ts": `export const beta = 2;\nexport const gamma = 3;`, + }); + try { + const snapshot = await api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const sfA = await project.program.getSourceFile("/src/a.ts"); + const sfB = await project.program.getSourceFile("/src/b.ts"); + assert.ok(sfA); + assert.ok(sfB); + const modA = await project.checker.getSymbolAtLocation(sfA); + const modB = await project.checker.getSymbolAtLocation(sfB); + assert.ok(modA); + assert.ok(modB); + const results = await project.checker.getExportsOfModule([modA, modB]); + assert.equal(results.length, 2); + assert.deepEqual(results[0].map(e => e.name), ["alpha"]); + const namesB = results[1].map(e => e.name); + assert.ok(namesB.includes("beta")); + assert.ok(namesB.includes("gamma")); + } + finally { + await api.close(); + } + }); + + test("getDeclaredTypeOfSymbol returns types for multiple symbols", async () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/main.ts": `interface Foo { x: number; }\ninterface Bar { y: string; }`, + }); + try { + const snapshot = await api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const src = `interface Foo { x: number; }\ninterface Bar { y: string; }`; + const posFoo = src.indexOf("Foo"); + const posBar = src.indexOf("Bar"); + const symFoo = await project.checker.getSymbolAtPosition("/src/main.ts", posFoo); + const symBar = await project.checker.getSymbolAtPosition("/src/main.ts", posBar); + assert.ok(symFoo); + assert.ok(symBar); + const types = await project.checker.getDeclaredTypeOfSymbol([symFoo, symBar]); + assert.equal(types.length, 2); + assert.ok(types[0].flags & TypeFlags.Object); + assert.ok(types[1].flags & TypeFlags.Object); + } + finally { + await api.close(); + } + }); + + test("getMemberInModuleExports resolves multiple members", async () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/index.ts": `export const alpha = 1;\nexport const beta = 2;`, + }); + try { + const snapshot = await api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const sourceFile = await project.program.getSourceFile("/src/index.ts"); + assert.ok(sourceFile); + const moduleSymbol = await project.checker.getSymbolAtLocation(sourceFile); + assert.ok(moduleSymbol); + const results = await project.checker.getMemberInModuleExports([ + { symbol: moduleSymbol, name: "alpha" }, + { symbol: moduleSymbol, name: "missing" }, + { symbol: moduleSymbol, name: "beta" }, + ]); + assert.equal(results.length, 3); + assert.equal(results[0]?.name, "alpha"); + assert.equal(results[1], undefined); + assert.equal(results[2]?.name, "beta"); + } + finally { + await api.close(); + } + }); +}); + describe("Symbol - getDocumentationComment and getJsDocTags", () => { const docFiles = { "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), diff --git a/_packages/native-preview/test/sync/api.test.ts b/_packages/native-preview/test/sync/api.test.ts index 0203aa28ffe..d002b850a6a 100644 --- a/_packages/native-preview/test/sync/api.test.ts +++ b/_packages/native-preview/test/sync/api.test.ts @@ -3847,6 +3847,143 @@ export * from "./inner"; }); }); +describe("Checker - batched methods", () => { + test("getImmediateAliasedSymbol resolves multiple aliases", () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const a = 1;`, + "/src/b.ts": `export const b = 2;`, + "/src/main.ts": `import { a } from "./a";\nimport { b } from "./b";\nexport const usage = a + b;`, + }); + try { + const snapshot = api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const posA = `import { a } from "./a";`.indexOf("a }"); + const posB = `import { a } from "./a";\nimport { b } from "./b";`.indexOf("b }"); + const symA = project.checker.getSymbolAtPosition("/src/main.ts", posA); + const symB = project.checker.getSymbolAtPosition("/src/main.ts", posB); + assert.ok(symA); + assert.ok(symB); + const results = project.checker.getImmediateAliasedSymbol([symA, symB]); + assert.equal(results.length, 2); + assert.equal(results[0]?.name, "a"); + assert.equal(results[1]?.name, "b"); + } + finally { + api.close(); + } + }); + + test("getAliasedSymbol resolves multiple import aliases", () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const a = 1;`, + "/src/b.ts": `export const b = 2;`, + "/src/main.ts": `import { a } from "./a";\nimport { b } from "./b";`, + }); + try { + const snapshot = api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const posA = `import { a } from "./a";`.indexOf("a }"); + const posB = `import { a } from "./a";\nimport { b } from "./b";`.indexOf("b }"); + const symA = project.checker.getSymbolAtPosition("/src/main.ts", posA); + const symB = project.checker.getSymbolAtPosition("/src/main.ts", posB); + assert.ok(symA); + assert.ok(symB); + const results = project.checker.getAliasedSymbol([symA, symB]); + assert.equal(results.length, 2); + assert.equal(results[0].name, "a"); + assert.ok(!(results[0].flags & SymbolFlags.Alias)); + assert.equal(results[1].name, "b"); + assert.ok(!(results[1].flags & SymbolFlags.Alias)); + } + finally { + api.close(); + } + }); + + test("getExportsOfModule returns exports for multiple modules", () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/a.ts": `export const alpha = 1;`, + "/src/b.ts": `export const beta = 2;\nexport const gamma = 3;`, + }); + try { + const snapshot = api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const sfA = project.program.getSourceFile("/src/a.ts"); + const sfB = project.program.getSourceFile("/src/b.ts"); + assert.ok(sfA); + assert.ok(sfB); + const modA = project.checker.getSymbolAtLocation(sfA); + const modB = project.checker.getSymbolAtLocation(sfB); + assert.ok(modA); + assert.ok(modB); + const results = project.checker.getExportsOfModule([modA, modB]); + assert.equal(results.length, 2); + assert.deepEqual(results[0].map(e => e.name), ["alpha"]); + const namesB = results[1].map(e => e.name); + assert.ok(namesB.includes("beta")); + assert.ok(namesB.includes("gamma")); + } + finally { + api.close(); + } + }); + + test("getDeclaredTypeOfSymbol returns types for multiple symbols", () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/main.ts": `interface Foo { x: number; }\ninterface Bar { y: string; }`, + }); + try { + const snapshot = api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const src = `interface Foo { x: number; }\ninterface Bar { y: string; }`; + const posFoo = src.indexOf("Foo"); + const posBar = src.indexOf("Bar"); + const symFoo = project.checker.getSymbolAtPosition("/src/main.ts", posFoo); + const symBar = project.checker.getSymbolAtPosition("/src/main.ts", posBar); + assert.ok(symFoo); + assert.ok(symBar); + const types = project.checker.getDeclaredTypeOfSymbol([symFoo, symBar]); + assert.equal(types.length, 2); + assert.ok(types[0].flags & TypeFlags.Object); + assert.ok(types[1].flags & TypeFlags.Object); + } + finally { + api.close(); + } + }); + + test("getMemberInModuleExports resolves multiple members", () => { + const api = spawnAPI({ + "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), + "/src/index.ts": `export const alpha = 1;\nexport const beta = 2;`, + }); + try { + const snapshot = api.updateSnapshot({ openProject: "/tsconfig.json" }); + const project = snapshot.getProject("/tsconfig.json")!; + const sourceFile = project.program.getSourceFile("/src/index.ts"); + assert.ok(sourceFile); + const moduleSymbol = project.checker.getSymbolAtLocation(sourceFile); + assert.ok(moduleSymbol); + const results = project.checker.getMemberInModuleExports([ + { symbol: moduleSymbol, name: "alpha" }, + { symbol: moduleSymbol, name: "missing" }, + { symbol: moduleSymbol, name: "beta" }, + ]); + assert.equal(results.length, 3); + assert.equal(results[0]?.name, "alpha"); + assert.equal(results[1], undefined); + assert.equal(results[2]?.name, "beta"); + } + finally { + api.close(); + } + }); +}); + describe("Symbol - getDocumentationComment and getJsDocTags", () => { const docFiles = { "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }), diff --git a/internal/api/proto.go b/internal/api/proto.go index fd064deec70..8be14d5e400 100644 --- a/internal/api/proto.go +++ b/internal/api/proto.go @@ -69,30 +69,31 @@ const ( // the connection itself and is not recorded. MethodResetServerTiming Method = "resetServerTiming" - MethodInitialize Method = "initialize" - MethodUpdateSnapshot Method = "updateSnapshot" - MethodUpdateTemporarySnapshot Method = "updateTemporarySnapshot" - MethodParseConfigFile Method = "parseConfigFile" - MethodGetDefaultProjectForFile Method = "getDefaultProjectForFile" - MethodGetSymbolAtPosition Method = "getSymbolAtPosition" - MethodGetSymbolsAtPositions Method = "getSymbolsAtPositions" - MethodGetSymbolAtLocation Method = "getSymbolAtLocation" - MethodGetSymbolsAtLocations Method = "getSymbolsAtLocations" - MethodGetTypeOfSymbol Method = "getTypeOfSymbol" - MethodGetTypesOfSymbols Method = "getTypesOfSymbols" - MethodGetDeclaredTypeOfSymbol Method = "getDeclaredTypeOfSymbol" - MethodGetSourceFile Method = "getSourceFile" - MethodGetSourceFileNames Method = "getSourceFileNames" - MethodGetSourceFileMetadata Method = "getSourceFileMetadata" + MethodInitialize Method = "initialize" + MethodUpdateSnapshot Method = "updateSnapshot" + MethodUpdateTemporarySnapshot Method = "updateTemporarySnapshot" + MethodParseConfigFile Method = "parseConfigFile" + MethodGetDefaultProjectForFile Method = "getDefaultProjectForFile" + MethodGetSymbolAtPosition Method = "getSymbolAtPosition" + MethodGetSymbolsAtPositions Method = "getSymbolsAtPositions" + MethodGetSymbolAtLocation Method = "getSymbolAtLocation" + MethodGetSymbolsAtLocations Method = "getSymbolsAtLocations" + MethodGetTypeOfSymbol Method = "getTypeOfSymbol" + MethodGetTypesOfSymbols Method = "getTypesOfSymbols" + MethodGetDeclaredTypeOfSymbol Method = "getDeclaredTypeOfSymbol" + MethodGetDeclaredTypesOfSymbols Method = "getDeclaredTypesOfSymbols" + MethodGetSourceFile Method = "getSourceFile" + MethodGetSourceFileNames Method = "getSourceFileNames" + MethodGetSourceFileMetadata Method = "getSourceFileMetadata" MethodGetConfigFileNames Method = "getConfigFileNames" MethodGetConfigSourceFile Method = "getConfigSourceFile" - MethodResolveName Method = "resolveName" - MethodGetSignaturesOfType Method = "getSignaturesOfType" - MethodGetResolvedSignature Method = "getResolvedSignature" - MethodGetTypeAtLocation Method = "getTypeAtLocation" - MethodGetTypeAtLocations Method = "getTypeAtLocations" - MethodGetTypeAtPosition Method = "getTypeAtPosition" - MethodGetTypesAtPositions Method = "getTypesAtPositions" + MethodResolveName Method = "resolveName" + MethodGetSignaturesOfType Method = "getSignaturesOfType" + MethodGetResolvedSignature Method = "getResolvedSignature" + MethodGetTypeAtLocation Method = "getTypeAtLocation" + MethodGetTypeAtLocations Method = "getTypeAtLocations" + MethodGetTypeAtPosition Method = "getTypeAtPosition" + MethodGetTypesAtPositions Method = "getTypesAtPositions" // Symbol sub-property methods MethodGetParentOfSymbol Method = "getParentOfSymbol" @@ -160,9 +161,13 @@ const ( MethodGetSignatureFromDeclaration Method = "getSignatureFromDeclaration" MethodGetExportSpecifierLocalTarget Method = "getExportSpecifierLocalTargetSymbol" MethodGetAliasedSymbol Method = "getAliasedSymbol" + MethodGetAliasedSymbols Method = "getAliasedSymbols" MethodGetImmediateAliasedSymbol Method = "getImmediateAliasedSymbol" + MethodGetImmediateAliasedSymbols Method = "getImmediateAliasedSymbols" MethodGetExportsOfModule Method = "getExportsOfModule" + MethodGetExportsOfModules Method = "getExportsOfModules" MethodGetMemberInModuleExports Method = "getMemberInModuleExports" + MethodGetMembersInModuleExports Method = "getMembersInModuleExports" MethodGetJSDocTags Method = "getJsDocTags" MethodGetDocumentationComment Method = "getDocumentationComment" MethodIsArrayType Method = "isArrayType" @@ -187,7 +192,7 @@ const ( MethodGetConfigFileParsingDiagnostics Method = "getConfigFileParsingDiagnostics" // Emitter methods - MethodPrintNode Method = "printNode" + MethodPrintNode Method = "printNode" MethodEmit Method = "emit" MethodEmitToString Method = "emitToString" MethodGetJavaScriptEmit Method = "getJavaScriptEmit" @@ -385,31 +390,32 @@ type UpdateSnapshotResponse struct { } var unmarshalers = map[Method]func([]byte) (any, error){ - MethodRelease: unmarshallerFor[ReleaseParams], - MethodInitialize: noParams, - MethodUpdateSnapshot: unmarshallerFor[UpdateSnapshotParams], - MethodUpdateTemporarySnapshot: unmarshallerFor[UpdateTemporarySnapshotParams], - MethodParseConfigFile: unmarshallerFor[ParseConfigFileParams], - MethodGetDefaultProjectForFile: unmarshallerFor[GetDefaultProjectForFileParams], - MethodGetSourceFile: unmarshallerFor[GetSourceFileParams], - MethodGetSourceFileNames: unmarshallerFor[GetSourceFileNamesParams], - MethodGetSourceFileMetadata: unmarshallerFor[GetSourceFileParams], + MethodRelease: unmarshallerFor[ReleaseParams], + MethodInitialize: noParams, + MethodUpdateSnapshot: unmarshallerFor[UpdateSnapshotParams], + MethodUpdateTemporarySnapshot: unmarshallerFor[UpdateTemporarySnapshotParams], + MethodParseConfigFile: unmarshallerFor[ParseConfigFileParams], + MethodGetDefaultProjectForFile: unmarshallerFor[GetDefaultProjectForFileParams], + MethodGetSourceFile: unmarshallerFor[GetSourceFileParams], + MethodGetSourceFileNames: unmarshallerFor[GetSourceFileNamesParams], + MethodGetSourceFileMetadata: unmarshallerFor[GetSourceFileParams], MethodGetConfigFileNames: unmarshallerFor[GetProjectDiagnosticsParams], MethodGetConfigSourceFile: unmarshallerFor[GetSourceFileParams], - MethodGetSymbolAtPosition: unmarshallerFor[GetSymbolAtPositionParams], - MethodGetSymbolsAtPositions: unmarshallerFor[GetSymbolsAtPositionsParams], - MethodGetSymbolAtLocation: unmarshallerFor[GetSymbolAtLocationParams], - MethodGetSymbolsAtLocations: unmarshallerFor[GetSymbolsAtLocationsParams], - MethodGetTypeOfSymbol: unmarshallerFor[GetTypeOfSymbolParams], - MethodGetTypesOfSymbols: unmarshallerFor[GetTypesOfSymbolsParams], - MethodGetDeclaredTypeOfSymbol: unmarshallerFor[GetTypeOfSymbolParams], - MethodResolveName: unmarshallerFor[ResolveNameParams], - MethodGetSignaturesOfType: unmarshallerFor[GetSignaturesOfTypeParams], - MethodGetResolvedSignature: unmarshallerFor[GetResolvedSignatureParams], - MethodGetTypeAtLocation: unmarshallerFor[GetTypeAtLocationParams], - MethodGetTypeAtLocations: unmarshallerFor[GetTypeAtLocationsParams], - MethodGetTypeAtPosition: unmarshallerFor[GetTypeAtPositionParams], - MethodGetTypesAtPositions: unmarshallerFor[GetTypesAtPositionsParams], + MethodGetSymbolAtPosition: unmarshallerFor[GetSymbolAtPositionParams], + MethodGetSymbolsAtPositions: unmarshallerFor[GetSymbolsAtPositionsParams], + MethodGetSymbolAtLocation: unmarshallerFor[GetSymbolAtLocationParams], + MethodGetSymbolsAtLocations: unmarshallerFor[GetSymbolsAtLocationsParams], + MethodGetTypeOfSymbol: unmarshallerFor[GetTypeOfSymbolParams], + MethodGetTypesOfSymbols: unmarshallerFor[GetTypesOfSymbolsParams], + MethodGetDeclaredTypeOfSymbol: unmarshallerFor[GetTypeOfSymbolParams], + MethodGetDeclaredTypesOfSymbols: unmarshallerFor[GetTypesOfSymbolsParams], + MethodResolveName: unmarshallerFor[ResolveNameParams], + MethodGetSignaturesOfType: unmarshallerFor[GetSignaturesOfTypeParams], + MethodGetResolvedSignature: unmarshallerFor[GetResolvedSignatureParams], + MethodGetTypeAtLocation: unmarshallerFor[GetTypeAtLocationParams], + MethodGetTypeAtLocations: unmarshallerFor[GetTypeAtLocationsParams], + MethodGetTypeAtPosition: unmarshallerFor[GetTypeAtPositionParams], + MethodGetTypesAtPositions: unmarshallerFor[GetTypesAtPositionsParams], MethodGetParentOfSymbol: unmarshallerFor[GetSymbolPropertyParams], MethodGetMembersOfSymbol: unmarshallerFor[GetSymbolPropertyParams], @@ -473,9 +479,13 @@ var unmarshalers = map[Method]func([]byte) (any, error){ MethodGetSignatureFromDeclaration: unmarshallerFor[CheckerNodeParams], MethodGetExportSpecifierLocalTarget: unmarshallerFor[CheckerNodeParams], MethodGetAliasedSymbol: unmarshallerFor[CheckerSymbolParams], + MethodGetAliasedSymbols: unmarshallerFor[CheckerSymbolsParams], MethodGetImmediateAliasedSymbol: unmarshallerFor[CheckerSymbolParams], + MethodGetImmediateAliasedSymbols: unmarshallerFor[CheckerSymbolsParams], MethodGetExportsOfModule: unmarshallerFor[CheckerSymbolParams], + MethodGetExportsOfModules: unmarshallerFor[CheckerSymbolsParams], MethodGetMemberInModuleExports: unmarshallerFor[GetMemberInModuleExportsParams], + MethodGetMembersInModuleExports: unmarshallerFor[GetMembersInModuleExportsParams], MethodGetJSDocTags: unmarshallerFor[CheckerSymbolParams], MethodGetDocumentationComment: unmarshallerFor[CheckerSymbolParams], MethodIsArrayType: unmarshallerFor[CheckerTypeParams], @@ -546,11 +556,11 @@ type GetDefaultProjectForFileParams struct { } type ProjectResponse struct { - Id ProjectID `json:"id"` - ConfigFileName string `json:"configFileName"` + Id ProjectID `json:"id"` + ConfigFileName string `json:"configFileName"` ParsedCommandLine *ConfigFileResponse `json:"parsedCommandLine"` - RootFiles []string `json:"rootFiles"` - CompilerOptions *core.CompilerOptions `json:"compilerOptions"` + RootFiles []string `json:"rootFiles"` + CompilerOptions *core.CompilerOptions `json:"compilerOptions"` } func NewConfigFileResponse(parsedCommandLine *tsoptions.ParsedCommandLine) *ConfigFileResponse { @@ -580,11 +590,11 @@ func NewProjectResponse(p *project.Project) *ProjectResponse { panic("NewProjectResponse called with unloaded project") } return &ProjectResponse{ - Id: ProjectHandle(p), - ConfigFileName: p.Name(), + Id: ProjectHandle(p), + ConfigFileName: p.Name(), ParsedCommandLine: NewConfigFileResponse(p.CommandLine), - RootFiles: p.CommandLine.FileNames(), - CompilerOptions: p.CommandLine.CompilerOptions(), + RootFiles: p.CommandLine.FileNames(), + CompilerOptions: p.CommandLine.CompilerOptions(), } } @@ -1195,6 +1205,24 @@ type CheckerSymbolParams struct { Symbol SymbolID `json:"symbol"` } +// CheckerSymbolsParams are parameters for checker methods that operate on a list of symbols. +type CheckerSymbolsParams struct { + Snapshot SnapshotID `json:"snapshot"` + Project ProjectID `json:"project"` + Symbols []SymbolID `json:"symbols"` +} + +type MemberInModuleExportsRequest struct { + Symbol SymbolID `json:"symbol"` + Name string `json:"name"` +} + +type GetMembersInModuleExportsParams struct { + Snapshot SnapshotID `json:"snapshot"` + Project ProjectID `json:"project"` + Requests []MemberInModuleExportsRequest `json:"requests"` +} + // JSDocTagInfo is a single JSDoc tag, mirroring Strada's JSDocTagInfo but with the tag text // rendered as a plain string rather than SymbolDisplayPart[]. type JSDocTagInfo struct { diff --git a/internal/api/session.go b/internal/api/session.go index 21060a91cbe..21b0c3a02ea 100644 --- a/internal/api/session.go +++ b/internal/api/session.go @@ -615,6 +615,8 @@ func (s *Session) HandleRequest(ctx context.Context, method string, params json. return s.handleGetTypesOfSymbols(ctx, parsed.(*GetTypesOfSymbolsParams)) case string(MethodGetDeclaredTypeOfSymbol): return s.handleGetDeclaredTypeOfSymbol(ctx, parsed.(*GetTypeOfSymbolParams)) + case string(MethodGetDeclaredTypesOfSymbols): + return s.handleGetDeclaredTypesOfSymbols(ctx, parsed.(*GetTypesOfSymbolsParams)) case string(MethodResolveName): return s.handleResolveName(ctx, parsed.(*ResolveNameParams)) case string(MethodGetSignaturesOfType): @@ -757,12 +759,20 @@ func (s *Session) HandleRequest(ctx context.Context, method string, params json. return s.handleGetExportSpecifierLocalTargetSymbol(ctx, parsed.(*CheckerNodeParams)) case string(MethodGetAliasedSymbol): return s.handleGetAliasedSymbol(ctx, parsed.(*CheckerSymbolParams)) + case string(MethodGetAliasedSymbols): + return s.handleGetAliasedSymbols(ctx, parsed.(*CheckerSymbolsParams)) case string(MethodGetImmediateAliasedSymbol): return s.handleGetImmediateAliasedSymbol(ctx, parsed.(*CheckerSymbolParams)) + case string(MethodGetImmediateAliasedSymbols): + return s.handleGetImmediateAliasedSymbols(ctx, parsed.(*CheckerSymbolsParams)) case string(MethodGetExportsOfModule): return s.handleGetExportsOfModule(ctx, parsed.(*CheckerSymbolParams)) + case string(MethodGetExportsOfModules): + return s.handleGetExportsOfModules(ctx, parsed.(*CheckerSymbolsParams)) case string(MethodGetMemberInModuleExports): return s.handleGetMemberInModuleExports(ctx, parsed.(*GetMemberInModuleExportsParams)) + case string(MethodGetMembersInModuleExports): + return s.handleGetMembersInModuleExports(ctx, parsed.(*GetMembersInModuleExportsParams)) case string(MethodGetJSDocTags): return s.handleGetJSDocTags(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetDocumentationComment): @@ -3021,6 +3031,132 @@ func (s *Session) handleGetMemberInModuleExports(ctx context.Context, params *Ge return setup.newSymbolResponse(member), nil } +func (s *Session) handleGetDeclaredTypesOfSymbols(ctx context.Context, params *GetTypesOfSymbolsParams) ([]*TypeResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + results := make([]*TypeResponse, len(params.Symbols)) + for i, symHandle := range params.Symbols { + symbol, err := setup.resolveSymbolHandle(symHandle) + if err != nil { + return nil, err + } + if symbol == nil { + continue + } + t := setup.checker.GetDeclaredTypeOfSymbol(symbol) + if t != nil { + results[i] = setup.newTypeResponse(t) + } + } + return results, nil +} + +func (s *Session) handleGetAliasedSymbols(ctx context.Context, params *CheckerSymbolsParams) ([]*SymbolResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + results := make([]*SymbolResponse, len(params.Symbols)) + for i, symHandle := range params.Symbols { + symbol, err := setup.resolveSymbolHandle(symHandle) + if err != nil { + return nil, err + } + if symbol == nil { + continue + } + aliased := setup.checker.GetAliasedSymbol(symbol) + if aliased != nil { + results[i] = setup.newSymbolResponse(aliased) + } + } + return results, nil +} + +func (s *Session) handleGetImmediateAliasedSymbols(ctx context.Context, params *CheckerSymbolsParams) ([]*SymbolResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + results := make([]*SymbolResponse, len(params.Symbols)) + for i, symHandle := range params.Symbols { + symbol, err := setup.resolveSymbolHandle(symHandle) + if err != nil { + return nil, err + } + if symbol == nil { + continue + } + aliased := setup.checker.GetImmediateAliasedSymbol(symbol) + if aliased != nil { + results[i] = setup.newSymbolResponse(aliased) + } + } + return results, nil +} + +func (s *Session) handleGetExportsOfModules(ctx context.Context, params *CheckerSymbolsParams) ([][]*SymbolResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + results := make([][]*SymbolResponse, len(params.Symbols)) + for i, symHandle := range params.Symbols { + symbol, err := setup.resolveSymbolHandle(symHandle) + if err != nil { + return nil, err + } + if symbol == nil { + continue + } + exports := setup.checker.GetExportsOfModule(symbol) + if len(exports) == 0 { + continue + } + slices.SortFunc(exports, setup.checker.CompareSymbols) + symbolResponses := make([]*SymbolResponse, len(exports)) + for j, exp := range exports { + symbolResponses[j] = setup.newSymbolResponse(exp) + } + results[i] = symbolResponses + } + return results, nil +} + +func (s *Session) handleGetMembersInModuleExports(ctx context.Context, params *GetMembersInModuleExportsParams) ([]*SymbolResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + results := make([]*SymbolResponse, len(params.Requests)) + for i, req := range params.Requests { + symbol, err := setup.resolveSymbolHandle(req.Symbol) + if err != nil { + return nil, err + } + if symbol == nil { + continue + } + member := setup.checker.TryGetMemberInModuleExports(req.Name, symbol) + if member != nil { + results[i] = setup.newSymbolResponse(member) + } + } + return results, nil +} + // handleGetJSDocTags returns the JSDoc tags of a symbol as structured name/text pairs. func (s *Session) handleGetJSDocTags(ctx context.Context, params *CheckerSymbolParams) ([]*JSDocTagInfo, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) From fd83a00c630f8b4bc73d25854936cb3bb44204bd Mon Sep 17 00:00:00 2001 From: tcernicovad1 Date: Wed, 29 Jul 2026 18:16:07 +0100 Subject: [PATCH 2/2] Fix CI issues --- _packages/native-preview/src/api/async/api.ts | 6 ++--- _packages/native-preview/src/api/sync/api.ts | 6 ++--- internal/api/proto.go | 26 +++++++++---------- 3 files changed, 19 insertions(+), 19 deletions(-) diff --git a/_packages/native-preview/src/api/async/api.ts b/_packages/native-preview/src/api/async/api.ts index 6c3945e3a5d..7151d60cc2d 100644 --- a/_packages/native-preview/src/api/async/api.ts +++ b/_packages/native-preview/src/api/async/api.ts @@ -1744,9 +1744,9 @@ export class Checker { return signature.id === (await this.getWellKnownSignatures()).unknown; } - async getExportsOfModule(symbol: Symbol): Promise; - async getExportsOfModule(symbols: readonly Symbol[]): Promise; - async getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { + async getExportsOfModule(symbol: Symbol): Promise; + async getExportsOfModule(symbols: readonly Symbol[]): Promise; + async getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): Promise { if (Array.isArray(symbolOrSymbols)) { const data = await this.client.apiRequest("getExportsOfModules", { snapshot: this.snapshotId, diff --git a/_packages/native-preview/src/api/sync/api.ts b/_packages/native-preview/src/api/sync/api.ts index 3985ecb339b..4bec70b2502 100644 --- a/_packages/native-preview/src/api/sync/api.ts +++ b/_packages/native-preview/src/api/sync/api.ts @@ -1752,9 +1752,9 @@ export class Checker { return signature.id === (this.getWellKnownSignatures()).unknown; } - getExportsOfModule(symbol: Symbol): readonly Symbol[]; - getExportsOfModule(symbols: readonly Symbol[]): readonly (readonly Symbol[])[]; - getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): readonly Symbol[] | readonly (readonly Symbol[])[] { + getExportsOfModule(symbol: Symbol): Symbol[]; + getExportsOfModule(symbols: readonly Symbol[]): Symbol[][]; + getExportsOfModule(symbolOrSymbols: Symbol | readonly Symbol[]): Symbol[] | Symbol[][] { if (Array.isArray(symbolOrSymbols)) { const data = this.client.apiRequest("getExportsOfModules", { snapshot: this.snapshotId, diff --git a/internal/api/proto.go b/internal/api/proto.go index 8be14d5e400..a685bb02d13 100644 --- a/internal/api/proto.go +++ b/internal/api/proto.go @@ -85,8 +85,8 @@ const ( MethodGetSourceFile Method = "getSourceFile" MethodGetSourceFileNames Method = "getSourceFileNames" MethodGetSourceFileMetadata Method = "getSourceFileMetadata" - MethodGetConfigFileNames Method = "getConfigFileNames" - MethodGetConfigSourceFile Method = "getConfigSourceFile" + MethodGetConfigFileNames Method = "getConfigFileNames" + MethodGetConfigSourceFile Method = "getConfigSourceFile" MethodResolveName Method = "resolveName" MethodGetSignaturesOfType Method = "getSignaturesOfType" MethodGetResolvedSignature Method = "getResolvedSignature" @@ -192,7 +192,7 @@ const ( MethodGetConfigFileParsingDiagnostics Method = "getConfigFileParsingDiagnostics" // Emitter methods - MethodPrintNode Method = "printNode" + MethodPrintNode Method = "printNode" MethodEmit Method = "emit" MethodEmitToString Method = "emitToString" MethodGetJavaScriptEmit Method = "getJavaScriptEmit" @@ -399,8 +399,8 @@ var unmarshalers = map[Method]func([]byte) (any, error){ MethodGetSourceFile: unmarshallerFor[GetSourceFileParams], MethodGetSourceFileNames: unmarshallerFor[GetSourceFileNamesParams], MethodGetSourceFileMetadata: unmarshallerFor[GetSourceFileParams], - MethodGetConfigFileNames: unmarshallerFor[GetProjectDiagnosticsParams], - MethodGetConfigSourceFile: unmarshallerFor[GetSourceFileParams], + MethodGetConfigFileNames: unmarshallerFor[GetProjectDiagnosticsParams], + MethodGetConfigSourceFile: unmarshallerFor[GetSourceFileParams], MethodGetSymbolAtPosition: unmarshallerFor[GetSymbolAtPositionParams], MethodGetSymbolsAtPositions: unmarshallerFor[GetSymbolsAtPositionsParams], MethodGetSymbolAtLocation: unmarshallerFor[GetSymbolAtLocationParams], @@ -556,11 +556,11 @@ type GetDefaultProjectForFileParams struct { } type ProjectResponse struct { - Id ProjectID `json:"id"` - ConfigFileName string `json:"configFileName"` + Id ProjectID `json:"id"` + ConfigFileName string `json:"configFileName"` ParsedCommandLine *ConfigFileResponse `json:"parsedCommandLine"` - RootFiles []string `json:"rootFiles"` - CompilerOptions *core.CompilerOptions `json:"compilerOptions"` + RootFiles []string `json:"rootFiles"` + CompilerOptions *core.CompilerOptions `json:"compilerOptions"` } func NewConfigFileResponse(parsedCommandLine *tsoptions.ParsedCommandLine) *ConfigFileResponse { @@ -590,11 +590,11 @@ func NewProjectResponse(p *project.Project) *ProjectResponse { panic("NewProjectResponse called with unloaded project") } return &ProjectResponse{ - Id: ProjectHandle(p), - ConfigFileName: p.Name(), + Id: ProjectHandle(p), + ConfigFileName: p.Name(), ParsedCommandLine: NewConfigFileResponse(p.CommandLine), - RootFiles: p.CommandLine.FileNames(), - CompilerOptions: p.CommandLine.CompilerOptions(), + RootFiles: p.CommandLine.FileNames(), + CompilerOptions: p.CommandLine.CompilerOptions(), } }