Fix no element imports and use alternate symbol resolution solution

hazzard993 · hazzard993 · commit 0dd855df8ac6 · 2019-06-19T23:04:07.000+10:00
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -357,11 +357,28 @@ export class LuaTransformer {
             scope.importStatements = [];
         }
 
+        let shouldResolve = true;
+        const moduleOwnerSymbol = this.checker.getSymbolAtLocation(statement.moduleSpecifier);
+        if (moduleOwnerSymbol) {
+            for (const declaration of moduleOwnerSymbol.declarations) {
+                if (tsHelper.isNonNamespaceModuleDeclaration(declaration)) {
+                    const type = this.checker.getTypeAtLocation(declaration);
+                    if (type) {
+                        const decorators = tsHelper.getCustomDecorators(type, this.checker);
+                        if (decorators.has(DecoratorKind.NoResolution)) {
+                            shouldResolve = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
         const moduleSpecifier = statement.moduleSpecifier as ts.StringLiteral;
         const importPath = moduleSpecifier.text.replace(new RegExp('"', "g"), "");
+        const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral, shouldResolve);
 
         if (!statement.importClause) {
-            const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral);
             result.push(tstl.createExpressionStatement(requireCall));
             if (scope.importStatements) {
                 scope.importStatements.push(...result);
@@ -376,28 +393,6 @@ export class LuaTransformer {
             throw TSTLErrors.UnsupportedImportType(statement.importClause);
         }
 
-        let shouldResolve = true;
-        if (ts.isNamedImports(imports)) {
-            for (const importSpecifier of imports.elements) {
-                const parentModule = tsHelper.getImportSpecifierModuleDeclaration(importSpecifier, this.checker);
-                if (parentModule) {
-                    const type = this.checker.getTypeAtLocation(parentModule);
-                    const decorators = tsHelper.getCustomDecorators(type, this.checker);
-                    if (decorators.has(DecoratorKind.NoResolution)) {
-                        shouldResolve = false;
-                        break;
-                    }
-                }
-            }
-        } else if (ts.isNamespaceImport(imports)) {
-            const type = this.checker.getTypeAtLocation(imports);
-            if (tsHelper.getCustomDecorators(type, this.checker).has(DecoratorKind.NoResolution)) {
-                shouldResolve = false;
-            }
-        }
-
-        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);
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -358,27 +358,6 @@ export class TSHelper {
         return directivesMap;
     }
 
-    public static getImportSpecifierModuleDeclaration(
-        node: ts.ImportSpecifier,
-        checker: ts.TypeChecker
-    ): ts.ModuleDeclaration | undefined {
-        const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-            const originalSymbol = checker.getAliasedSymbol(symbol);
-            if (originalSymbol.declarations) {
-                for (const declaration of originalSymbol.declarations) {
-                    const parentAmbientModule = this.findFirstNodeAbove(
-                        declaration,
-                        this.isNonNamespaceModuleDeclaration
-                    );
-                    if (parentAmbientModule) {
-                        return parentAmbientModule;
-                    }
-                }
-            }
-        }
-    }
-
     // Search up until finding a node satisfying the callback
     public static findFirstNodeAbove<T extends ts.Node>(
         node: ts.Node,
diff --git a/test/unit/require.spec.ts b/test/unit/require.spec.ts
@@ -151,6 +151,21 @@ test.each([
         mainCode: "import { y } from 'fake'; y;",
         expectedPath: "src.fake",
     },
+    {
+        declarationStatement: `
+            declare module 'fake' {}
+        `,
+        mainCode: "import 'fake';",
+        expectedPath: "src.fake",
+    },
+    {
+        declarationStatement: `
+            /** @noResolution */
+            declare module 'fake' {}
+        `,
+        mainCode: "import 'fake';",
+        expectedPath: "fake",
+    },
 ])("noResolution prevents any module path resolution behaviour", ({ declarationStatement, mainCode, expectedPath }) => {
     const lua = util.transpileString({
         "src/main.ts": mainCode,
