diff --git a/.chronus/changes/fix-subpath-emitter-identity.md b/.chronus/changes/fix-subpath-emitter-identity.md new file mode 100644 index 00000000000..eafbc6e7bc4 --- /dev/null +++ b/.chronus/changes/fix-subpath-emitter-identity.md @@ -0,0 +1,7 @@ +--- +changeKind: fix +packages: + - "@typespec/compiler" +--- + +Resolve emitters exported from package subpaths using their declared `$lib.name`, giving each emitter its own options, default output directory, and runtime reporting. Package-keyed options remain supported as a fallback. diff --git a/packages/compiler/src/core/program.ts b/packages/compiler/src/core/program.ts index 9c5b6acaf4b..619c1fa7a90 100644 --- a/packages/compiler/src/core/program.ts +++ b/packages/compiler/src/core/program.ts @@ -750,8 +750,12 @@ async function createProgram( const emitFunction = entrypoint.esmExports.$onEmit; const libDefinition = library.definition; + let emitterOptionsKey = metadata.name ?? emitterNameOrPath; + if (!Object.hasOwn(emittersOptions, emitterOptionsKey) && library.module.type === "module") { + emitterOptionsKey = library.module.manifest.name; + } let { "emitter-output-dir": emitterOutputDir, ...emitterOptions } = - emittersOptions[metadata.name ?? emitterNameOrPath] ?? {}; + emittersOptions[emitterOptionsKey] ?? {}; if (emitterOutputDir === undefined) { emitterOutputDir = [options.outputDir, metadata.name].filter(isDefined).join("/"); } @@ -767,7 +771,7 @@ async function createProgram( options.configFile?.file ? { kind: "path-target", - path: ["options", emitterNameOrPath], + path: ["options", emitterOptionsKey], script: options.configFile.file, } : NoTarget, @@ -837,7 +841,10 @@ async function createProgram( }; } - return computeModuleMetadata(module); + return { + ...computeModuleMetadata(module), + name: libDefinition?.name ?? module.manifest.name, + }; } function computeModuleMetadata(module: ResolvedModule): ModuleLibraryMetadata { diff --git a/packages/compiler/test/core/emitter-options.test.ts b/packages/compiler/test/core/emitter-options.test.ts index 014546ef973..1e8e8904dce 100644 --- a/packages/compiler/test/core/emitter-options.test.ts +++ b/packages/compiler/test/core/emitter-options.test.ts @@ -1,9 +1,11 @@ -import { ok, strictEqual } from "assert"; +import { deepStrictEqual, ok, strictEqual } from "assert"; import { describe, it } from "vitest"; +import { getSourceLocation } from "../../src/core/diagnostics.js"; import type { Diagnostic, EmitContext } from "../../src/index.js"; import { createTypeSpecLibrary } from "../../src/index.js"; import { expectDiagnosticEmpty, expectDiagnostics } from "../../src/testing/expect.js"; import { mockFile } from "../../src/testing/fs.js"; +import { parseYaml } from "../../src/yaml/parser.js"; import { Tester } from "../tester.js"; const fakeEmitter = createTypeSpecLibrary({ @@ -72,6 +74,131 @@ it("pass options", async () => { strictEqual(context.options["max-files"], 10); }); +describe("subpath emitters", () => { + const typescriptEmitter = "fake-emitter/typescript"; + const jsonSchemaEmitter = "fake-emitter/json-schema"; + + function createSubpathEmitters() { + const contexts: EmitContext[] = []; + const files: Record> = { + "node_modules/fake-emitter/package.json": JSON.stringify({ + name: "fake-emitter", + exports: { + "./ts": "./typescript/index.js", + "./json-schema": "./json-schema/index.js", + }, + }), + }; + for (const name of [typescriptEmitter, jsonSchemaEmitter]) { + files[`node_modules/${name}/index.js`] = mockFile.js({ + $lib: createTypeSpecLibrary({ + name, + diagnostics: {}, + emitter: fakeEmitter.emitter, + }), + $onEmit: (context: EmitContext) => { + contexts.push(context); + }, + }); + } + return { tester: Tester.files(files), contexts }; + } + + it("uses each library's declared name for options, output directories, and statistics", async () => { + const { tester, contexts } = createSubpathEmitters(); + const { program } = await tester.compile("", { + compilerOptions: { + emit: ["fake-emitter/ts", jsonSchemaEmitter], + outputDir: "/out", + options: { + "fake-emitter": { "max-files": 99, "emitter-output-dir": "/legacy" }, + [typescriptEmitter]: { "max-files": 10 }, + [jsonSchemaEmitter]: { "max-files": 20 }, + }, + }, + }); + + deepStrictEqual( + contexts.map(({ options, emitterOutputDir }) => ({ options, emitterOutputDir })), + [ + { options: { "max-files": 10 }, emitterOutputDir: `/out/${typescriptEmitter}` }, + { options: { "max-files": 20 }, emitterOutputDir: `/out/${jsonSchemaEmitter}` }, + ], + ); + deepStrictEqual(Object.keys(program.stats.runtime.emit.emitters), [ + typescriptEmitter, + jsonSchemaEmitter, + ]); + }); + + it("retains package-name options as a fallback", async () => { + const { tester, contexts } = createSubpathEmitters(); + await tester.compile("", { + compilerOptions: { + emit: ["fake-emitter/ts"], + options: { + "fake-emitter": { "max-files": 10, "emitter-output-dir": "/legacy" }, + }, + }, + }); + + strictEqual(contexts[0].options["max-files"], 10); + strictEqual(contexts[0].emitterOutputDir, "/legacy"); + }); + + it.each([typescriptEmitter, "fake-emitter"])( + "targets schema diagnostics at options configured under %s", + async (optionsKey) => { + const { tester } = createSubpathEmitters(); + const [configFile] = parseYaml(`options:\n ${optionsKey}:\n max-files: not-a-number\n`); + const diagnostics = await tester.diagnose("", { + compilerOptions: { + emit: ["fake-emitter/ts"], + options: { [optionsKey]: { "max-files": "not-a-number" } }, + configFile: { + projectRoot: ".", + diagnostics: [], + outputDir: "tsp-output", + file: configFile, + }, + }, + }); + + expectDiagnostics(diagnostics, { + code: "invalid-schema", + message: "Schema violation: must be number (/max-files)", + }); + const location = getSourceLocation(diagnostics[0].target); + ok(location); + strictEqual(location.file.text.slice(location.pos, location.end), "max-files"); + }, + ); +}); + +it("uses the declared library name for filesystem package emitters", async () => { + let context: EmitContext | undefined; + await Tester.files({ + "../local-emitter/package.json": JSON.stringify({ + name: "fake-emitter", + main: "index.js", + }), + "../local-emitter/index.js": mockFile.js({ + $lib: createTypeSpecLibrary({ name: "fake-emitter/typescript", diagnostics: {} }), + $onEmit: (emitContext: EmitContext) => { + context = emitContext; + }, + }), + }).compile("", { + compilerOptions: { + emit: ["../local-emitter"], + outputDir: "/out", + }, + }); + + ok(context); + strictEqual(context.emitterOutputDir, "/out/fake-emitter/typescript"); +}); + it("emit diagnostic if passing unknown option", async () => { const diagnostics = await diagnoseEmitterOptions({ "invalid-option": "abc",