Merge plugin and transformer diagnostics

ark120202 · ark120202 · commit b1069da0a9f5 · 2020-03-11T13:44:46.000Z
diff --git a/src/transpilation/diagnostics.ts b/src/transpilation/diagnostics.ts
@@ -10,23 +10,14 @@ const createDiagnostic = (messageText: string, category = ts.DiagnosticCategory.
     messageText,
 });
 
-export const toLoadPluginItShouldBeTranspiled = (transform: string) =>
-    createDiagnostic(`To load "${transform}" plugin it should be transpiled or "ts-node" should be installed`);
+export const toLoadItShouldBeTranspiled = (kind: string, transform: string) =>
+    createDiagnostic(`To load "${transform}" ${kind} it should be transpiled or "ts-node" should be installed`);
 
-export const couldNotResolvePluginFrom = (transform: string, base: string) =>
-    createDiagnostic(`Could not resolve "${transform}" plugin from "${base}".`);
+export const couldNotResolveFrom = (kind: string, transform: string, base: string) =>
+    createDiagnostic(`Could not resolve "${transform}" ${kind} from "${base}".`);
 
-export const pluginShouldHaveAExport = (transform: string, importName: string) =>
-    createDiagnostic(`"${transform}" plugin should have a "${importName}" export`);
-
-export const toLoadTransformerItShouldBeTranspiled = (transform: string) =>
-    createDiagnostic(`To load "${transform}" transformer it should be transpiled or "ts-node" should be installed`);
-
-export const couldNotResolveTransformerFrom = (transform: string, base: string) =>
-    createDiagnostic(`Could not resolve "${transform}" transformer from "${base}".`);
-
-export const transformerShouldHaveAExport = (transform: string, importName: string) =>
-    createDiagnostic(`"${transform}" transformer should have a "${importName}" export`);
+export const shouldHaveAExport = (kind: string, transform: string, importName: string) =>
+    createDiagnostic(`"${transform}" ${kind} should have a "${importName}" export`);
 
 export const transformerShouldBeATsTransformerFactory = (transform: string) =>
     createDiagnostic(
diff --git a/src/transpilation/plugins.ts b/src/transpilation/plugins.ts
@@ -29,13 +29,9 @@ export function getPlugins(program: ts.Program, diagnostics: ts.Diagnostic[], cu
         const optionName = `tstl.luaPlugins[${index}]`;
 
         const { error: resolveError, result: factory } = resolvePlugin(
-            {
-                couldNotResolveFrom: diagnosticFactories.couldNotResolvePluginFrom,
-                toLoadItShouldBeTranspiled: diagnosticFactories.toLoadPluginItShouldBeTranspiled,
-                shouldHaveAExport: diagnosticFactories.pluginShouldHaveAExport,
-            },
-            getConfigDirectory(options),
+            "plugin",
             `${optionName}.plugin`,
+            getConfigDirectory(options),
             pluginOption.plugin,
             pluginOption.import
         );
diff --git a/src/transpilation/transformers.ts b/src/transpilation/transformers.ts
@@ -68,13 +68,9 @@ function loadTransformersFromOptions(program: ts.Program, diagnostics: ts.Diagno
         const optionName = `compilerOptions.plugins[${index}]`;
 
         const { error: resolveError, result: factory } = resolvePlugin(
-            {
-                couldNotResolveFrom: diagnosticFactories.couldNotResolveTransformerFrom,
-                toLoadItShouldBeTranspiled: diagnosticFactories.toLoadTransformerItShouldBeTranspiled,
-                shouldHaveAExport: diagnosticFactories.transformerShouldHaveAExport,
-            },
-            getConfigDirectory(options),
+            "transformer",
             `${optionName}.transform`,
+            getConfigDirectory(options),
             transformerImport.transform,
             transformerImport.import
         );
diff --git a/src/transpilation/utils.ts b/src/transpilation/utils.ts
@@ -1,22 +1,17 @@
+import * as path from "path";
 import * as resolve from "resolve";
 import * as ts from "typescript";
-import * as path from "path";
 // TODO: Don't depend on CLI?
 import * as cliDiagnostics from "../cli/diagnostics";
+import * as diagnosticFactories from "./diagnostics";
 
 export const getConfigDirectory = (options: ts.CompilerOptions) =>
     options.configFilePath ? path.dirname(options.configFilePath) : process.cwd();
 
-interface ResolvePluginDiagnostics {
-    couldNotResolveFrom(query: string, base: string): ts.Diagnostic;
-    toLoadItShouldBeTranspiled(query: string): ts.Diagnostic;
-    shouldHaveAExport(query: string, importName: string): ts.Diagnostic;
-}
-
 export function resolvePlugin(
-    diagnostics: ResolvePluginDiagnostics,
-    basedir: string,
+    kind: string,
     optionName: string,
+    basedir: string,
     query: string,
     importName = "default"
 ): { error?: ts.Diagnostic; result?: unknown } {
@@ -29,7 +24,7 @@ export function resolvePlugin(
         resolved = resolve.sync(query, { basedir, extensions: [".js", ".ts", ".tsx"] });
     } catch (err) {
         if (err.code !== "MODULE_NOT_FOUND") throw err;
-        return { error: diagnostics.couldNotResolveFrom(query, basedir) };
+        return { error: diagnosticFactories.couldNotResolveFrom(kind, query, basedir) };
     }
 
     // tslint:disable-next-line: deprecation
@@ -41,13 +36,13 @@ export function resolvePlugin(
             tsNode.register({ transpileOnly: true });
         } catch (err) {
             if (err.code !== "MODULE_NOT_FOUND") throw err;
-            return { error: diagnostics.toLoadItShouldBeTranspiled(query) };
+            return { error: diagnosticFactories.toLoadItShouldBeTranspiled(kind, query) };
         }
     }
 
     const result = require(resolved)[importName];
     if (result === undefined) {
-        return { error: diagnostics.shouldHaveAExport(query, importName) };
+        return { error: diagnosticFactories.shouldHaveAExport(kind, query, importName) };
     }
 
     return { result };
