All tests working

Perryvw · Perryvw · commit c080110dea8f · 2021-05-24T17:09:31.000+02:00
diff --git a/src/transformation/utils/diagnostics.ts b/src/transformation/utils/diagnostics.ts
@@ -124,10 +124,6 @@ export const invalidAmbientIdentifierName = createErrorDiagnosticFactory(
     (text: string) => `Invalid ambient identifier name '${text}'. Ambient identifiers must be valid lua identifiers.`
 );
 
-export const unresolvableRequirePath = createErrorDiagnosticFactory(
-    (path: string) => `Cannot create require path. Module '${path}' does not exist within --rootDir.`
-);
-
 export const unsupportedVarDeclaration = createErrorDiagnosticFactory(
     "`var` declarations are not supported. Use `let` or `const` instead."
 );
diff --git a/src/transpilation/bundle.ts b/src/transpilation/bundle.ts
@@ -33,10 +33,7 @@ local function require(file)
 end
 `;
 
-export function getBundleResult(
-    program: ts.Program,
-    files: ProcessedFile[]
-): [ts.Diagnostic[], EmitFile] {
+export function getBundleResult(program: ts.Program, files: ProcessedFile[]): [ts.Diagnostic[], EmitFile] {
     const diagnostics: ts.Diagnostic[] = [];
 
     const options = program.getCompilerOptions() as CompilerOptions;
diff --git a/src/transpilation/diagnostics.ts b/src/transpilation/diagnostics.ts
@@ -4,6 +4,15 @@ import { createSerialDiagnosticFactory } from "../utils";
 const createDiagnosticFactory = <TArgs extends any[]>(getMessage: (...args: TArgs) => string) =>
     createSerialDiagnosticFactory((...args: TArgs) => ({ messageText: getMessage(...args) }));
 
+export const couldNotResolveRequire = createDiagnosticFactory(
+    (require: string, containingFile: string) =>
+        `Could not resolve require path '${require}' in file ${containingFile}.`
+);
+
+export const couldNotReadDependency = createDiagnosticFactory(
+    (dependency: string) => `Could not read content of resolved dependency ${dependency}.`
+);
+
 export const toLoadItShouldBeTranspiled = createDiagnosticFactory(
     (kind: string, transform: string) =>
         `To load "${transform}" ${kind} it should be transpiled or "ts-node" should be installed.`
diff --git a/src/transpilation/resolve.ts b/src/transpilation/resolve.ts
@@ -4,7 +4,9 @@ import * as ts from "typescript";
 import * as fs from "fs";
 import { EmitHost, ProcessedFile } from "./utils";
 import { SourceNode } from "source-map";
-import { getEmitPathRelativeToOutDir, getSourceDir } from "./transpiler";
+import { getEmitPathRelativeToOutDir, getProjectRoot, getSourceDir } from "./transpiler";
+import { formatPathToLuaPath } from "../utils";
+import { couldNotReadDependency, couldNotResolveRequire } from "./diagnostics";
 
 const resolver = resolve.ResolverFactory.createResolver({
     extensions: [".lua"],
@@ -13,19 +15,38 @@ const resolver = resolve.ResolverFactory.createResolver({
     useSyncFileSystemCalls: true,
 });
 
-export function resolveDependencies(program: ts.Program, files: ProcessedFile[], emitHost: EmitHost): ProcessedFile[] {
-    const outFiles = [];
+const projectFiles = new Map<string, string>();
+
+interface ResolutionResult {
+    resolvedFiles: ProcessedFile[];
+    diagnostics: ts.Diagnostic[];
+}
+
+export function resolveDependencies(program: ts.Program, files: ProcessedFile[], emitHost: EmitHost): ResolutionResult {
+    const outFiles: ProcessedFile[] = [];
+    const diagnostics: ts.Diagnostic[] = [];
+
+    const projectRoot = getProjectRoot(program);
+    for (const sourceFile of program.getSourceFiles()) {
+        const filePath = path.isAbsolute(sourceFile.fileName)
+            ? path.normalize(sourceFile.fileName)
+            : path.resolve(projectRoot, sourceFile.fileName);
+        projectFiles.set(filePath, sourceFile.text);
+    }
 
     for (const file of files) {
-        outFiles.push(file, ...resolveFileDependencies(file, program, emitHost));
+        const resolutionResult = resolveFileDependencies(file, program, emitHost);
+        outFiles.push(file, ...resolutionResult.resolvedFiles);
+        diagnostics.push(...resolutionResult.diagnostics);
     }
 
-    return outFiles;
+    return { resolvedFiles: outFiles, diagnostics };
 }
 
-function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitHost: EmitHost): ProcessedFile[] {
+function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitHost: EmitHost): ResolutionResult {
     const projectRootDir = getSourceDir(program);
     const dependencies: ProcessedFile[] = [];
+    const diagnostics: ts.Diagnostic[] = [];
     for (const required of findRequiredPaths(file.code)) {
         // Do no resolve lualib
         if (required === "lualib_bundle") {
@@ -34,20 +55,21 @@ function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitH
 
         // Do not resolve noResolution paths
         if (required.startsWith("@NoResolution:")) {
-            const path = required.replace("@NoResolution:", "")
+            const path = required.replace("@NoResolution:", "");
             replaceRequireInCode(file, required, path);
             replaceRequireInSourceMap(file, required, path);
             continue;
         }
-        
+
         // Try to resolve the import starting from the directory `file` is in
         const fileDir = path.dirname(file.fileName);
-        const resolvedDependency = resolveDependency(fileDir, projectRootDir, required, emitHost);
+        const resolvedDependency = resolveDependency(fileDir, projectRootDir, required);
         if (resolvedDependency) {
             // If dependency resolved successfully, read its content
-            const dependencyContent = emitHost.readFile(resolvedDependency);
+            const dependencyContent = projectFiles.get(resolvedDependency) ?? emitHost.readFile(resolvedDependency);
             if (dependencyContent === undefined) {
-                throw `TODO: FAILED TO READ ${resolvedDependency}`;
+                diagnostics.push(couldNotReadDependency(resolvedDependency));
+                continue;
             }
 
             // Figure out resolved require path and dependency output path
@@ -57,28 +79,34 @@ function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitH
             replaceRequireInSourceMap(file, required, resolvedRequire);
 
             // If dependency is not part of sources, add dependency to output and resolve its dependencies recursively
-            if (!program.getSourceFile(resolvedDependency)) {
+            if (!projectFiles.has(resolvedDependency)) {
                 const dependency = {
                     fileName: resolvedDependency,
                     code: dependencyContent,
                 };
-                dependencies.push(dependency, ...resolveFileDependencies(dependency, program, emitHost));
+                const nestedDependencies = resolveFileDependencies(dependency, program, emitHost);
+                dependencies.push(dependency, ...nestedDependencies.resolvedFiles);
+                diagnostics.push(...nestedDependencies.diagnostics);
             }
         } else {
-            console.error(`Failed to resolve ${required} referenced in ${file.fileName}.`);
-            console.error(projectRootDir);
+            // Could not resolve dependency, add a diagnostic and make some fallback path
+            diagnostics.push(couldNotResolveRequire(required, path.relative(projectRootDir, file.fileName)));
+
+            const fallbackRequire = fallbackResolve(required, projectRootDir, fileDir);
+            replaceRequireInCode(file, required, fallbackRequire);
+            replaceRequireInSourceMap(file, required, fallbackRequire);
         }
     }
-    return dependencies;
+    return { resolvedFiles: dependencies, diagnostics };
 }
 
 function replaceRequireInCode(file: ProcessedFile, originalRequire: string, newRequire: string) {
-    const requirePath = newRequire.replace(".lua", "").replace(/\\/g, ".");
+    const requirePath = formatPathToLuaPath(newRequire.replace(".lua", ""));
     file.code = file.code.replace(`require("${originalRequire}")`, `require("${requirePath}")`);
 }
 
 function replaceRequireInSourceMap(file: ProcessedFile, originalRequire: string, newRequire: string) {
-    const requirePath = newRequire.replace(".lua", "").replace(/\\/g, ".");
+    const requirePath = formatPathToLuaPath(newRequire.replace(".lua", ""));
     if (file.sourceMapNode) {
         replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire}"`, `"${requirePath}"`);
     }
@@ -114,23 +142,22 @@ function findRequiredPaths(code: string): string[] {
     return paths;
 }
 
-function resolveDependency(fileDirectory: string, rootDirectory: string, dependency: string, emitHost: EmitHost): string | undefined {
+function resolveDependency(fileDirectory: string, rootDirectory: string, dependency: string): string | undefined {
     // Check if file is a TS file in the project
-    const dependencyPath = dependency;
-    const resolvedPath = path.resolve(fileDirectory, dependencyPath);
-    const resolvedFile = resolvedPath + ".ts";
+    const resolvedPath = path.resolve(fileDirectory, dependency);
 
-    if (emitHost.fileExists(resolvedFile)) {
-        return resolvedPath + ".ts";
+    const resolvedFile = resolvedPath + ".ts";
+    if (projectFiles.has(resolvedFile)) {
+        return resolvedFile;
     }
 
-    const projectIndexPath = path.resolve(fileDirectory, dependencyPath, "index.ts");
-    if (emitHost.fileExists(projectIndexPath)) {
+    const projectIndexPath = path.resolve(resolvedPath, "index.ts");
+    if (projectFiles.has(projectIndexPath)) {
         return projectIndexPath;
     }
 
     try {
-        const resolveResult = resolver.resolveSync({}, rootDirectory, dependencyPath);
+        const resolveResult = resolver.resolveSync({}, rootDirectory, dependency);
         if (resolveResult) {
             return resolveResult;
         }
@@ -140,3 +167,14 @@ function resolveDependency(fileDirectory: string, rootDirectory: string, depende
 
     return undefined;
 }
+
+// Transform an import path to a lua require that is probably not correct, but can be used as fallback when regular resolution fails
+function fallbackResolve(required: string, projectRootDir: string, fileDir: string): string {
+    return formatPathToLuaPath(
+        path
+            .normalize(path.join(path.relative(projectRootDir, fileDir), required))
+            .split(path.sep)
+            .filter(s => s !== "." && s !== "..")
+            .join(path.sep)
+    );
+}
diff --git a/src/transpilation/transpiler.ts b/src/transpilation/transpiler.ts
@@ -58,20 +58,25 @@ export class Transpiler {
 
         const lualibRequired = files.some(f => f.code.includes('require("lualib_bundle")'));
         if (lualibRequired) {
-            const fileName = normalizeSlashes(path.resolve(getEmitOutDir(program), "lualib_bundle.lua"));
+            // Add lualib bundle to source dir 'virtually', will be moved to correct output dir in emitPlan
+            const fileName = normalizeSlashes(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
             files.unshift({ fileName, code: getLuaLibBundle(this.emitHost) });
         }
 
         // Resolve imported modules and modify output Lua requires
-        const resolvedFiles = resolveDependencies(program, files, this.emitHost);
+        const resolutionResult = resolveDependencies(program, files, this.emitHost);
+        diagnostics.push(...resolutionResult.diagnostics);
 
         let emitPlan: EmitFile[];
         if (isBundleEnabled(options)) {
-            const [bundleDiagnostics, bundleFile] = getBundleResult(program, resolvedFiles);
+            const [bundleDiagnostics, bundleFile] = getBundleResult(program, resolutionResult.resolvedFiles);
             diagnostics.push(...bundleDiagnostics);
             emitPlan = [bundleFile];
         } else {
-            emitPlan = resolvedFiles.map(file => ({ ...file, outputPath: getEmitPath(file.fileName, program) }));
+            emitPlan = resolutionResult.resolvedFiles.map(file => ({
+                ...file,
+                outputPath: getEmitPath(file.fileName, program),
+            }));
         }
 
         return { emitPlan };
diff --git a/test/translation/transformation.spec.ts b/test/translation/transformation.spec.ts
@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as tstl from "../../src";
 import { annotationDeprecated } from "../../src/transformation/utils/diagnostics";
+import { couldNotResolveRequire } from "../../src/transpilation/diagnostics";
 import * as util from "../util";
 
 const fixturesPath = path.join(__dirname, "./transformation");
@@ -14,7 +15,7 @@ const fixtures = fs
 test.each(fixtures)("Transformation (%s)", (_name, content) => {
     util.testModule(content)
         .setOptions({ luaLibImport: tstl.LuaLibImportKind.Require })
-        .ignoreDiagnostics([annotationDeprecated.code])
+        .ignoreDiagnostics([annotationDeprecated.code, couldNotResolveRequire.code])
         .disableSemanticCheck()
         .expectLuaToMatchSnapshot();
 });
diff --git a/test/transpile/__snapshots__/directories.spec.ts.snap b/test/transpile/__snapshots__/directories.spec.ts.snap
@@ -1,13 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`should be able to resolve ({"name": "baseurl", "options": [Object]}) 1`] = `
-Array [
-  "directories/baseurl/out/lualib_bundle.lua",
-  "directories/baseurl/out/src/lib/nested/file.lua",
-  "directories/baseurl/out/src/main.lua",
-]
-`;
-
 exports[`should be able to resolve ({"name": "basic", "options": [Object]}) 1`] = `
 Array [
   "directories/basic/src/lib/file.lua",
diff --git a/test/transpile/directories.spec.ts b/test/transpile/directories.spec.ts
@@ -13,7 +13,6 @@ test.each<DirectoryTestCase>([
     { name: "basic", options: { outDir: "out" } },
     { name: "basic", options: { rootDir: "src" } },
     { name: "basic", options: { rootDir: "src", outDir: "out" } },
-    { name: "baseurl", options: { baseUrl: "./src/lib", rootDir: ".", outDir: "./out" } },
 ])("should be able to resolve (%p)", ({ name, options: compilerOptions }) => {
     const projectPath = path.join(__dirname, "directories", name);
     jest.spyOn(process, "cwd").mockReturnValue(projectPath);
diff --git a/test/transpile/directories/baseurl/src/lib/nested/file.ts b/test/transpile/directories/baseurl/src/lib/nested/file.ts
diff --git a/test/transpile/directories/baseurl/src/main.ts b/test/transpile/directories/baseurl/src/main.ts
diff --git a/test/transpile/module-resolution.spec.ts b/test/transpile/module-resolution.spec.ts
@@ -127,7 +127,7 @@ describe("module resolution with outDir", () => {
             .setMainFileName(mainFile)
             .setOptions({ outDir: "tstl-out", luaBundle: "bundle.lua", luaBundleEntry: mainFile })
             .expectToEqual({ result: "dependency3" });
-        
+
         // Get the output paths relative to the project path
         const outPaths = builder.getLuaResult().transpiledFiles.map(f => path.relative(projectPath, f.outPath));
         expect(outPaths).toHaveLength(1);
diff --git a/test/transpile/module-resolution/project-with-dependency-chain/main.ts b/test/transpile/module-resolution/project-with-dependency-chain/main.ts
@@ -1,3 +1,3 @@
 import * as dependency1 from "dependency1";
 
-export const result = dependency1.f1();
+export const result = dependency1.f1();
diff --git a/test/transpile/module-resolution/project-with-sourceDir/src/main.ts b/test/transpile/module-resolution/project-with-sourceDir/src/main.ts
@@ -2,4 +2,4 @@ import * as dependency1 from "dependency1";
 import { func } from "./subdir/otherfile";
 
 export const result = dependency1.f1();
-export const result2 = func();
+export const result2 = func();
diff --git a/test/transpile/module-resolution/project-with-sourceDir/src/subdir/otherfile.ts b/test/transpile/module-resolution/project-with-sourceDir/src/subdir/otherfile.ts
@@ -1,3 +1,3 @@
 export function func() {
     return "non-node_modules import";
-}
+}
diff --git a/test/transpile/module-resolution/project-with-sourceDir/tsconfig.json b/test/transpile/module-resolution/project-with-sourceDir/tsconfig.json
@@ -8,6 +8,6 @@
         "lib": ["esnext"],
         "types": [],
         "rootDir": "src",
-        "outDir": "tstl-out",
+        "outDir": "tstl-out"
     }
 }
diff --git a/test/unit/modules/__snapshots__/resolution.spec.ts.snap b/test/unit/modules/__snapshots__/resolution.spec.ts.snap
@@ -2,9 +2,9 @@
 
 exports[`doesn't resolve paths out of root dir: code 1`] = `
 "local ____exports = {}
-local module = require(\\"../module\\")
+local module = require(\\"module\\")
 local ____ = module
 return ____exports"
 `;
 
-exports[`doesn't resolve paths out of root dir: diagnostics 1`] = `"src/main.ts(2,33): error TSTL: Cannot create require path. Module '../module' does not exist within --rootDir."`;
+exports[`doesn't resolve paths out of root dir: diagnostics 1`] = `"error TSTL: Could not resolve require path '../module' in file main.ts."`;
diff --git a/test/unit/modules/modules.spec.ts b/test/unit/modules/modules.spec.ts
@@ -58,8 +58,7 @@ test.each(["ke-bab", "dollar$", "singlequote'", "hash#", "s p a c e", "ɥɣɎɌ
             import { foo } from "./${name}";
             export { foo };
         `
-            .disableSemanticCheck()
-            .setLuaHeader('setmetatable(package.loaded, { __index = function() return { foo = "bar" } end })')
+            .addExtraFile(`${name}.ts`, 'export const foo = "bar";')
             .setReturnExport("foo")
             .expectToEqual("bar");
     }
diff --git a/test/unit/modules/resolution.spec.ts b/test/unit/modules/resolution.spec.ts
@@ -1,5 +1,5 @@
 import * as ts from "typescript";
-import { unresolvableRequirePath } from "../../../src/transformation/utils/diagnostics";
+import { couldNotResolveRequire } from "../../../src/transpilation/diagnostics";
 import * as util from "../../util";
 
 const requireRegex = /require\("(.*?)"\)/;
@@ -69,6 +69,7 @@ test.each([
         module;
     `
         .setMainFileName(filePath)
+        .addExtraFile(`${usedPath}.ts`, "")
         .setOptions(options)
         .tap(expectToRequire(expected));
 });
@@ -81,7 +82,7 @@ test("doesn't resolve paths out of root dir", () => {
         .setMainFileName("src/main.ts")
         .setOptions({ rootDir: "./src" })
         .disableSemanticCheck()
-        .expectDiagnosticsToMatchSnapshot([unresolvableRequirePath.code]);
+        .expectDiagnosticsToMatchSnapshot([couldNotResolveRequire.code]);
 });
 
 test.each([
diff --git a/test/unit/printer/sourcemaps.spec.ts b/test/unit/printer/sourcemaps.spec.ts
@@ -1,5 +1,6 @@
 import { Position, SourceMapConsumer } from "source-map";
 import * as tstl from "../../../src";
+import { couldNotResolveRequire } from "../../../src/transpilation/diagnostics";
 import * as util from "../../util";
 
 test.each([
@@ -144,7 +145,11 @@ test.each([
         ],
     },
 ])("Source map has correct mapping (%p)", async ({ code, assertPatterns }) => {
-    const file = util.testModule(code).expectToHaveNoDiagnostics().getMainLuaFileResult();
+    const file = util
+        .testModule(code)
+        .ignoreDiagnostics([couldNotResolveRequire.code])
+        .expectToHaveNoDiagnostics()
+        .getMainLuaFileResult();
 
     const consumer = await new SourceMapConsumer(file.luaSourceMap);
     for (const { luaPattern, typeScriptPattern } of assertPatterns) {
