check origin for standard library types (#468)

TheLartians · Perryvw · commit 52d04f9c9e6b · 2019-03-06T19:57:44.000+01:00
* detect global console

* added test

* actually check if type is a DOM declaration

* refactor helper methods

* check standard library type origins

* revert for constructors

* check constructors again and assume lib for no valueDeclaration

* make program protected
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -47,6 +47,8 @@ export class LuaTransformer {
 
     private checker: ts.TypeChecker;
     protected options: CompilerOptions;
+    protected program: ts.Program;
+
     private isModule: boolean;
 
     private currentSourceFile?: ts.SourceFile;
@@ -68,6 +70,7 @@ export class LuaTransformer {
     public constructor(program: ts.Program, options: CompilerOptions) {
         this.checker = program.getTypeChecker();
         this.options = options;
+        this.program = program;
         this.isStrict = this.options.alwaysStrict || (this.options.strict && this.options.alwaysStrict !== false) ||
                         (this.isModule && this.options.target && this.options.target >= ts.ScriptTarget.ES2015);
 
@@ -3113,7 +3116,7 @@ export class LuaTransformer {
         }
 
         const expressionType = this.checker.getTypeAtLocation(node.expression);
-        if (expressionType.symbol && expressionType.symbol.escapedName === "SymbolConstructor") {
+        if (tsHelper.isStandardLibraryType(expressionType, "SymbolConstructor", this.program)) {
             return this.transformLuaLibFunction(LuaLibFeature.Symbol, node, ...parameters);
         }
 
@@ -3132,27 +3135,27 @@ export class LuaTransformer {
         // If the function being called is of type owner.func, get the type of owner
         const ownerType = this.checker.getTypeAtLocation(node.expression.expression);
 
-        if (ownerType.symbol && ownerType.symbol.escapedName === "Math") {
+        if (tsHelper.isStandardLibraryType(ownerType, "Math", this.program)) {
             return this.transformMathCallExpression(node);
         }
 
-        if (ownerType.symbol && ownerType.symbol.escapedName === "StringConstructor") {
+        if (tsHelper.isStandardLibraryType(ownerType, "Console", this.program)) {
+            return this.transformConsoleCallExpression(node);
+        }
+
+        if (tsHelper.isStandardLibraryType(ownerType, "StringConstructor", this.program)) {
             return tstl.createCallExpression(
                 this.transformStringExpression(node.expression.name),
                 this.transformArguments(node.arguments),
                 node
             );
         }
 
-        if (ownerType.symbol && ownerType.symbol.escapedName === "ObjectConstructor") {
+        if (tsHelper.isStandardLibraryType(ownerType, "ObjectConstructor", this.program)) {
             return this.transformObjectCallExpression(node);
         }
 
-        if (ownerType.symbol && ownerType.symbol.escapedName === "Console") {
-            return this.transformConsoleCallExpression(node);
-        }
-
-        if (ownerType.symbol && ownerType.symbol.escapedName === "SymbolConstructor") {
+        if (tsHelper.isStandardLibraryType(ownerType, "SymbolConstructor", this.program)) {
             return this.transformSymbolCallExpression(node);
         }
 
@@ -3317,9 +3320,11 @@ export class LuaTransformer {
 
         // Catch math expressions
         if (ts.isIdentifier(node.expression)) {
-            if (node.expression.escapedText === "Math") {
+            const ownerType = this.checker.getTypeAtLocation(node.expression);
+
+            if (tsHelper.isStandardLibraryType(ownerType, "Math", this.program)) {
                 return this.transformMathExpression(node.name);
-            } else if (node.expression.escapedText === "Symbol") {
+            } else if (tsHelper.isStandardLibraryType(ownerType, "Symbol", this.program)) {
                 // Pull in Symbol lib
                 this.importLuaLibFeature(LuaLibFeature.Symbol);
             }
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -297,7 +297,7 @@ export class TSHelper {
         return node.parent === undefined || ts.isExpressionStatement(node.parent) || ts.isForStatement(node.parent);
     }
 
-    public static isInGlobalScope(node: ts.FunctionDeclaration): boolean {
+    public static isInGlobalScope(node: ts.Node): boolean {
         let parent = node.parent;
         while (parent !== undefined) {
             if (ts.isBlock(parent)) {
@@ -687,6 +687,20 @@ export class TSHelper {
         return firstDeclaration === node;
     }
 
+    public static isStandardLibraryDeclaration(declaration: ts.Declaration, program: ts.Program): boolean {
+        const source = declaration.getSourceFile();
+        if (!source) { return false; }
+        return program.isSourceFileDefaultLibrary(source);
+    }
+
+    public static isStandardLibraryType(type: ts.Type, name: string, program: ts.Program): boolean {
+        const symbol = type.symbol;
+        if (!symbol || symbol.escapedName !== name) { return false; }
+        const declaration = symbol.valueDeclaration;
+        if(!declaration) { return true; } // assume to be lib function if no valueDeclaration exists
+        return this.isStandardLibraryDeclaration(declaration, program);
+    }
+
     public static isEnumMember(enumDeclaration: ts.EnumDeclaration, value: ts.Expression): [boolean, ts.PropertyName] {
         if (ts.isIdentifier(value)) {
             const enumMember = enumDeclaration.members.find(m => ts.isIdentifier(m.name) && m.name.text === value.text);
diff --git a/test/unit/console.spec.ts b/test/unit/console.spec.ts
@@ -1,4 +1,4 @@
-import { Expect, Test, TestCase, IgnoreTest, FocusTest } from "alsatian";
+import { Expect, Test, TestCase } from "alsatian";
 import * as util from "../src/util";
 
 export class ConsoleTests {
@@ -45,4 +45,23 @@ export class ConsoleTests {
         Expect(lua).toBe(expected);
     }
 
+    @Test("console.differentiation")
+    public testConsoleDifferentiation(): void {
+        // Transpile
+        const result = util.transpileExecuteAndReturnExport(`
+          export class Console {
+            test() { return 42; }
+          }
+
+          function test() {
+            const console = new Console();
+            return console.test();
+          }
+
+          export const result = test();
+        `, "result");
+        Expect(result).toBe(42);
+    }
+
+
 }
