No path resolution for ambient modules (#455)

hazzard993 · Perryvw · commit f9a225e49c2b · 2019-03-14T17:17:59.000+01:00
* Added special console translations

* Added tests

* Renamed to ConsoleTests

* Imported modules are not resolved

* Added module tests

* Refactored to isAmbientModuleDeclaration

* removed interfering tests

* private to public

* Fixed broken test

* Moved isAmbientModuleDeclaration to tsHelper

* Refactored to use resolveModule param

* Added noResolution decorator

* Used new decorator

* Correction

* Fixed test

* Added param to StringCompilerProgram for multiple files

* Updated noResolution tests

* Merged extraFiles param with input

* AAA consideration and updated transpileString
diff --git a/src/Compiler.ts b/src/Compiler.ts
@@ -89,7 +89,10 @@ const defaultCompilerOptions: CompilerOptions = {
 };
 
 export function createStringCompilerProgram(
-    input: string, options: CompilerOptions = defaultCompilerOptions, filePath = "file.ts"): ts.Program {
+    input: string | { [filename: string]: string },
+    options: CompilerOptions = defaultCompilerOptions,
+    filePath = "file.ts"
+): ts.Program {
     const compilerHost =  {
         directoryExists: () => true,
         fileExists: (fileName): boolean => true,
@@ -100,8 +103,17 @@ export function createStringCompilerProgram(
         getNewLine: () => "\n",
 
         getSourceFile: (filename: string) => {
-            if (filename === filePath) {
-                return ts.createSourceFile(filename, input, ts.ScriptTarget.Latest, false);
+            switch (typeof input) {
+                case "string":
+                    if (filename === filePath) {
+                        return ts.createSourceFile(filename, input, ts.ScriptTarget.Latest, false);
+                    }
+                    break;
+                case "object":
+                    if (filename in input) {
+                        return ts.createSourceFile(filename, input[filename], ts.ScriptTarget.Latest, false);
+                    }
+                    break;
             }
             if (filename.indexOf(".d.ts") !== -1) {
                 if (!libCache[filename]) {
@@ -125,16 +137,17 @@ export function createStringCompilerProgram(
         // Don't write output
         writeFile: (name, text, writeByteOrderMark) => undefined,
     };
-    return ts.createProgram([filePath], options, compilerHost);
+    const filePaths = typeof input === "string" ? [filePath] : Object.keys(input);
+    return ts.createProgram(filePaths, options, compilerHost);
 }
 
 export function transpileString(
-    str: string,
+    input: string | { [filename: string]: string },
     options: CompilerOptions = defaultCompilerOptions,
     ignoreDiagnostics = false,
     filePath = "file.ts"
 ): string {
-    const program = createStringCompilerProgram(str, options, filePath);
+    const program = createStringCompilerProgram(input, options, filePath);
 
     if (!ignoreDiagnostics) {
         const diagnostics = ts.getPreEmitDiagnostics(program);
diff --git a/src/Decorator.ts b/src/Decorator.ts
@@ -13,6 +13,8 @@ export class Decorator {
                 return DecoratorKind.CustomConstructor;
             case "compilemembersonly":
                 return DecoratorKind.CompileMembersOnly;
+            case "noresolution":
+                return DecoratorKind.NoResolution;
             case "pureabstract":
                 return DecoratorKind.PureAbstract;
             case "phantom":
@@ -42,6 +44,7 @@ export enum DecoratorKind {
     MetaExtension = "MetaExtension",
     CustomConstructor = "CustomConstructor",
     CompileMembersOnly = "CompileMembersOnly",
+    NoResolution = "NoResolution",
     PureAbstract = "PureAbstract",
     Phantom = "Phantom",
     TupleReturn = "TupleReturn",
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -318,14 +318,17 @@ export class LuaTransformer {
         const moduleSpecifier = statement.moduleSpecifier as ts.StringLiteral;
         const importPath = moduleSpecifier.text.replace(new RegExp("\"", "g"), "");
 
-        const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral);
-
         if (!statement.importClause) {
+            const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral);
             result.push(tstl.createExpressionStatement(requireCall));
             return result;
         }
 
         const imports = statement.importClause.namedBindings;
+        const type = this.checker.getTypeAtLocation(imports);
+        const shouldResolve = !tsHelper.getCustomDecorators(type, this.checker).has(DecoratorKind.NoResolution);
+        const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral, shouldResolve);
+
         if (ts.isNamedImports(imports)) {
             const filteredElements = imports.elements.filter(e => {
                 const decorators = tsHelper.getCustomDecorators(this.checker.getTypeAtLocation(e), this.checker);
@@ -379,11 +382,12 @@ export class LuaTransformer {
         }
     }
 
-    private createModuleRequire(moduleSpecifier: ts.StringLiteral): tstl.CallExpression {
-        const importPath = moduleSpecifier.text.replace(new RegExp("\"", "g"), "");
-        const resolvedModuleSpecifier = tstl.createStringLiteral(this.getImportPath(importPath));
-
-        return tstl.createCallExpression(tstl.createIdentifier("require"), [resolvedModuleSpecifier]);
+    private createModuleRequire(moduleSpecifier: ts.StringLiteral, resolveModule = true): tstl.CallExpression {
+        const modulePathString = resolveModule
+            ? this.getImportPath(moduleSpecifier.text.replace(new RegExp("\"", "g"), ""))
+            : moduleSpecifier.text;
+        const modulePath = tstl.createStringLiteral(modulePathString);
+        return tstl.createCallExpression(tstl.createIdentifier("require"), [modulePath]);
     }
 
     public transformClassDeclaration(
diff --git a/test/src/util.ts b/test/src/util.ts
@@ -12,10 +12,11 @@ import * as fs from "fs";
 import { LuaTransformer } from "../../src/LuaTransformer";
 
 export function transpileString(
-    str: string,
+    str: string | { [filename: string]: string },
     options?: CompilerOptions,
     ignoreDiagnostics = true,
-    filePath = "file.ts"): string {
+    filePath = "file.ts"
+): string {
     if (options) {
         if (options.noHeader === undefined) {
             options.noHeader = true;
diff --git a/test/unit/require.spec.ts b/test/unit/require.spec.ts
@@ -23,14 +23,26 @@ export class RequireTests {
         expectedPath: string,
         options: CompilerOptions,
         throwsError: boolean): void {
-        const regex = /require\("(.*?)"\)/;                 // This regex extracts `hello` from require("hello")
         if (throwsError) {
             Expect(() => util.transpileString(`import * from "${usedPath}";`, options, true, filePath)).toThrow();
         } else {
             const lua = util.transpileString(`import * from "${usedPath}";`, options, true, filePath);
+            const regex = /require\("(.*?)"\)/;
             const match = regex.exec(lua);
             Expect(match[1]).toBe(expectedPath);
         }
     }
 
+    @TestCase("", "src.fake")
+    @TestCase("/** @noResolution */", "fake")
+    @Test("noResolution on ambient modules causes no path alterations")
+    public testRequireModule(comment: string, expectedPath: string): void {
+        const lua = util.transpileString({
+            "src/file.ts": `import * as fake from "fake";`,
+            "module.d.ts": `${comment} declare module "fake" {}`,
+        }, undefined, true, "src/file.ts");
+        const regex = /require\("(.*?)"\)/;
+        Expect(regex.exec(lua)[1]).toBe(expectedPath);
+    }
+
 }
