Add support for custom transformers

Author: jakebailey

src/compiler/emitter.ts

@@ -1334,6 +1334,7 @@ function emitUsingBuildInfoWorker(
         getFileIncludeReasons: notImplemented,
         createHash: maybeBind(host, host.createHash),
     };
+    // TODO(jakebailey): customTransformers
     emitFiles(
         notImplementedResolver,
         emitHost,

src/compiler/program.ts

@@ -53,6 +53,7 @@ import {
     createTypeChecker,
     createTypeReferenceDirectiveResolutionCache,
     CustomTransformers,
+    CustomTransformersModuleFactory,
     Debug,
     DeclarationWithTypeParameterChildren,
     Diagnostic,
@@ -153,6 +154,7 @@ import {
     getTsBuildInfoEmitOutputFilePath,
     getTsConfigObjectLiteralExpression,
     getTsConfigPropArrayElementValue,
+    getTypeScriptNamespace,
     HasChangedAutomaticTypeDirectiveNames,
     hasChangesInResolutions,
     hasExtension,
@@ -218,6 +220,7 @@ import {
     mapDefinedIterator,
     maybeBind,
     memoize,
+    mergeCustomTransformers,
     MethodDeclaration,
     ModeAwareCache,
     ModeAwareCacheKey,
@@ -499,7 +502,8 @@ export function createCompilerHostWorker(options: CompilerOptions, setParentNode
         realpath,
         readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
         createDirectory: d => system.createDirectory(d),
-        createHash: maybeBind(system, system.createHash)
+        createHash: maybeBind(system, system.createHash),
+        require: maybeBind(system, system.require),
     };
     return compilerHost;
 }
@@ -2670,6 +2674,30 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         return hasEmitBlockingDiagnostics.has(toPath(emitFileName));
     }
 
+    function getCustomTransformers() {
+        if (!host.require) {
+            return emptyArray;
+        }
+
+        const compilerOptions = program.getCompilerOptions();
+        const customTransformers = mapDefined(compilerOptions.plugins, config => {
+            if (config.type !== "transformer") return undefined;
+
+            // TODO(jakebailey): The LS plugin loader is more complicated than this; copy.
+            const result = host.require!(program.getCurrentDirectory(), config.path);
+            // TODO(jakebailey): error handling, only do this once per, etc
+            Debug.assertIsDefined(result.module);
+
+            const factory = result.module as CustomTransformersModuleFactory;
+            Debug.assert(typeof factory === "function");
+
+            const plugin = factory({ typescript: getTypeScriptNamespace() });
+            return plugin.create({ program, config });
+        });
+
+        return customTransformers ?? emptyArray;
+    }
+
     function emitWorker(program: Program, sourceFile: SourceFile | undefined, writeFileCallback: WriteFileCallback | undefined, cancellationToken: CancellationToken | undefined, emitOnly?: boolean | EmitOnly, customTransformers?: CustomTransformers, forceDtsEmit?: boolean): EmitResult {
         if (!forceDtsEmit) {
             const result = handleNoEmitOptions(program, sourceFile, writeFileCallback, cancellationToken);
@@ -2688,11 +2716,13 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
 
         performance.mark("beforeEmit");
 
+        const mergedCustomTransformers = mergeCustomTransformers(...getCustomTransformers(), customTransformers);
+
         const emitResult = emitFiles(
             emitResolver,
             getEmitHost(writeFileCallback),
             sourceFile,
-            getTransformers(options, customTransformers, emitOnly),
+            getTransformers(options, mergedCustomTransformers, emitOnly),
             emitOnly,
             /*onlyBuildInfo*/ false,
             forceDtsEmit

src/compiler/transformer.ts

@@ -4,6 +4,7 @@ import {
     Bundle,
     chainBundle,
     CompilerOptions,
+    concatenate,
     createEmitHelperFactory,
     CustomTransformer,
     CustomTransformerFactory,
@@ -116,6 +117,21 @@ export function getTransformers(compilerOptions: CompilerOptions, customTransfor
     };
 }
 
+/** @internal */
+export function mergeCustomTransformers(...customTransformers: (CustomTransformers | undefined)[]): CustomTransformers | undefined {
+    if (!some(customTransformers)) return undefined;
+
+    const result: CustomTransformers = {};
+    for (const transformer of customTransformers) {
+        if (!transformer) continue;
+        result.before = concatenate(result.before, transformer.before);
+        result.after = concatenate(result.after, transformer.after);
+        result.afterDeclarations = concatenate(result.afterDeclarations, transformer.afterDeclarations);
+    }
+
+    return result;
+}
+
 function getScriptTransformers(compilerOptions: CompilerOptions, customTransformers?: CustomTransformers, emitOnly?: boolean | EmitOnly) {
     if (emitOnly) return emptyArray;
 

src/compiler/types.ts

@@ -17,6 +17,7 @@ import {
     SymlinkCache,
     ThisContainer,
 } from "./_namespaces/ts";
+import * as ts from "./_namespaces/ts";
 
 // branded string type used to store absolute, normalized and canonicalized paths
 // arbitrary file name can be converted to Path via toPath function
@@ -7022,8 +7023,18 @@ export enum ModuleDetectionKind {
     Force = 3,
 }
 
+export type PluginConfig = PluginImport | TransformerPluginImport;
+
 export interface PluginImport {
+    type?: undefined;
     name: string;
+    /** @internal */
+    global?: boolean;
+}
+
+export interface TransformerPluginImport {
+    type: "transformer",
+    path: string;
 }
 
 export interface ProjectReference {
@@ -7060,7 +7071,7 @@ export enum PollingWatchKind {
     FixedChunkSize,
 }
 
-export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginConfig[] | ProjectReference[] | null | undefined;
 
 export interface CompilerOptions {
     /** @internal */ all?: boolean;
@@ -7161,7 +7172,7 @@ export interface CompilerOptions {
      * @internal
      */
     pathsBasePath?: string;
-    /** @internal */ plugins?: PluginImport[];
+    /** @internal */ plugins?: PluginConfig[];
     preserveConstEnums?: boolean;
     noImplicitOverride?: boolean;
     preserveSymlinks?: boolean;
@@ -7207,6 +7218,7 @@ export interface CompilerOptions {
     esModuleInterop?: boolean;
     /** @internal */ showConfig?: boolean;
     useDefineForClassFields?: boolean;
+    customTransformers?: string[];
 
     [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
 }
@@ -7806,6 +7818,7 @@ export interface CompilerHost extends ModuleResolutionHost {
     createHash?(data: string): string;
     getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
     /** @internal */ useSourceOfProjectReferenceRedirect?(): boolean;
+    /** @internal */ require?(baseDir: string, moduleName: string): ModuleImportResult;
 
     // TODO: later handle this in better way in builder host instead once the api for tsbuild finalizes and doesn't use compilerHost as base
     /** @internal */createDirectory?(directory: string): void;
@@ -9973,3 +9986,19 @@ export interface Queue<T> {
     dequeue(): T;
     isEmpty(): boolean;
 }
+
+export type CustomTransformersModuleFactory = (mod: { typescript: typeof ts }) => CustomTransformersModule;
+
+export interface CustomTransformersModuleWithName {
+    name: string;
+    module: CustomTransformersModule;
+}
+
+export interface CustomTransformersModule {
+    create(createInfo: CustomTransformersCreateInfo): CustomTransformers;
+}
+
+export interface CustomTransformersCreateInfo {
+    program: Program;
+    config: any;
+}

src/server/project.ts

@@ -1851,12 +1851,12 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
             if (!globalPluginName) continue;
 
             // Skip already-locally-loaded plugins
-            if (options.plugins && options.plugins.some(p => p.name === globalPluginName)) continue;
+            if (options.plugins && options.plugins.some(p => p.type === undefined && p.name === globalPluginName)) continue;
 
             // Provide global: true so plugins can detect why they can't find their config
             this.projectService.logger.info(`Loading global plugin ${globalPluginName}`);
 
-            this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths);
+            this.enablePlugin({ name: globalPluginName, global: true }, searchPaths);
         }
     }
 
@@ -2711,7 +2711,9 @@ export class ConfiguredProject extends Project {
         // Enable tsconfig-specified plugins
         if (options.plugins) {
             for (const pluginConfigEntry of options.plugins) {
-                this.enablePlugin(pluginConfigEntry, searchPaths);
+                if (pluginConfigEntry.type === undefined) {
+                    this.enablePlugin(pluginConfigEntry, searchPaths);
+                }
             }
         }
 

tests/baselines/reference/api/tsclibrary.d.ts

@@ -2996,9 +2996,15 @@ declare namespace ts {
          */
         Force = 3
     }
+    type PluginConfig = PluginImport | TransformerPluginImport;
     interface PluginImport {
+        type?: undefined;
         name: string;
     }
+    interface TransformerPluginImport {
+        type: "transformer";
+        path: string;
+    }
     interface ProjectReference {
         /** A normalized path on disk */
         path: string;
@@ -3029,7 +3035,7 @@ declare namespace ts {
         DynamicPriority = 2,
         FixedChunkSize = 3
     }
-    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginConfig[] | ProjectReference[] | null | undefined;
     interface CompilerOptions {
         allowImportingTsExtensions?: boolean;
         allowJs?: boolean;
@@ -3134,6 +3140,7 @@ declare namespace ts {
         verbatimModuleSyntax?: boolean;
         esModuleInterop?: boolean;
         useDefineForClassFields?: boolean;
+        customTransformers?: string[];
         [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
     }
     interface WatchOptions {
@@ -4263,6 +4270,20 @@ declare namespace ts {
         negative: boolean;
         base10Value: string;
     }
+    type CustomTransformersModuleFactory = (mod: {
+        typescript: typeof ts;
+    }) => CustomTransformersModule;
+    interface CustomTransformersModuleWithName {
+        name: string;
+        module: CustomTransformersModule;
+    }
+    interface CustomTransformersModule {
+        create(createInfo: CustomTransformersCreateInfo): CustomTransformers;
+    }
+    interface CustomTransformersCreateInfo {
+        program: Program;
+        config: any;
+    }
     enum FileWatcherEventKind {
         Created = 0,
         Changed = 1,

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -7127,9 +7127,15 @@ declare namespace ts {
          */
         Force = 3
     }
+    type PluginConfig = PluginImport | TransformerPluginImport;
     interface PluginImport {
+        type?: undefined;
         name: string;
     }
+    interface TransformerPluginImport {
+        type: "transformer";
+        path: string;
+    }
     interface ProjectReference {
         /** A normalized path on disk */
         path: string;
@@ -7160,7 +7166,7 @@ declare namespace ts {
         DynamicPriority = 2,
         FixedChunkSize = 3
     }
-    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginConfig[] | ProjectReference[] | null | undefined;
     interface CompilerOptions {
         allowImportingTsExtensions?: boolean;
         allowJs?: boolean;
@@ -7265,6 +7271,7 @@ declare namespace ts {
         verbatimModuleSyntax?: boolean;
         esModuleInterop?: boolean;
         useDefineForClassFields?: boolean;
+        customTransformers?: string[];
         [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
     }
     interface WatchOptions {
@@ -8397,6 +8404,20 @@ declare namespace ts {
         negative: boolean;
         base10Value: string;
     }
+    type CustomTransformersModuleFactory = (mod: {
+        typescript: typeof ts;
+    }) => CustomTransformersModule;
+    interface CustomTransformersModuleWithName {
+        name: string;
+        module: CustomTransformersModule;
+    }
+    interface CustomTransformersModule {
+        create(createInfo: CustomTransformersCreateInfo): CustomTransformers;
+    }
+    interface CustomTransformersCreateInfo {
+        program: Program;
+        config: any;
+    }
     enum FileWatcherEventKind {
         Created = 0,
         Changed = 1,

tests/baselines/reference/api/typescript.d.ts

@@ -3081,9 +3081,15 @@ declare namespace ts {
          */
         Force = 3
     }
+    type PluginConfig = PluginImport | TransformerPluginImport;
     interface PluginImport {
+        type?: undefined;
         name: string;
     }
+    interface TransformerPluginImport {
+        type: "transformer";
+        path: string;
+    }
     interface ProjectReference {
         /** A normalized path on disk */
         path: string;
@@ -3114,7 +3120,7 @@ declare namespace ts {
         DynamicPriority = 2,
         FixedChunkSize = 3
     }
-    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
+    type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginConfig[] | ProjectReference[] | null | undefined;
     interface CompilerOptions {
         allowImportingTsExtensions?: boolean;
         allowJs?: boolean;
@@ -3219,6 +3225,7 @@ declare namespace ts {
         verbatimModuleSyntax?: boolean;
         esModuleInterop?: boolean;
         useDefineForClassFields?: boolean;
+        customTransformers?: string[];
         [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
     }
     interface WatchOptions {
@@ -4351,6 +4358,20 @@ declare namespace ts {
         negative: boolean;
         base10Value: string;
     }
+    type CustomTransformersModuleFactory = (mod: {
+        typescript: typeof ts;
+    }) => CustomTransformersModule;
+    interface CustomTransformersModuleWithName {
+        name: string;
+        module: CustomTransformersModule;
+    }
+    interface CustomTransformersModule {
+        create(createInfo: CustomTransformersCreateInfo): CustomTransformers;
+    }
+    interface CustomTransformersCreateInfo {
+        program: Program;
+        config: any;
+    }
     enum FileWatcherEventKind {
         Created = 0,
         Changed = 1,