TypeScriptToLua · Perryvw · Jan 28, 2019 · Jan 27, 2019
diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -2,8 +2,8 @@ import * as ts from "typescript";
 
 export interface CompilerOptions extends ts.CompilerOptions {
     noHeader?: boolean;
-    luaTarget?: string;
-    luaLibImport?: string;
+    luaTarget?: LuaTarget;
+    luaLibImport?: LuaLibImportKind;
 }
 
 export enum LuaLibImportKind {

diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -46,9 +46,9 @@ export class LuaTransformer {
 
     private readonly typeValidationCache: Map<ts.Type, Set<ts.Type>> = new Map<ts.Type, Set<ts.Type>>();
 
-    public constructor(program: ts.Program) {
+    public constructor(program: ts.Program, options: CompilerOptions) {
         this.checker = program.getTypeChecker();
-        this.options = program.getCompilerOptions();
+        this.options = options;
         this.isStrict = this.options.alwaysStrict || (this.options.strict && this.options.alwaysStrict !== false) ||
                         (this.isModule && this.options.target && this.options.target >= ts.ScriptTarget.ES2015);
 

diff --git a/src/LuaTranspiler.ts b/src/LuaTranspiler.ts
@@ -4,7 +4,7 @@ import * as ts from "typescript";
 
 import * as tstl from "./LuaAST";
 
-import {CompilerOptions, LuaLibImportKind} from "./CompilerOptions";
+import {CompilerOptions, LuaLibImportKind, LuaTarget} from "./CompilerOptions";
 import {LuaPrinter} from "./LuaPrinter";
 import {LuaTransformer} from "./LuaTransformer";
 
@@ -19,11 +19,25 @@ export class LuaTranspiler {
 
     constructor(program: ts.Program) {
         this.program = program;
-        this.options = this.program.getCompilerOptions() as CompilerOptions;
-        this.luaTransformer = new LuaTransformer(this.program);
+        this.options = this.getOptions(program);
+        this.luaTransformer = new LuaTransformer(this.program, this.options);
         this.luaPrinter = new LuaPrinter(this.options);
     }
 
+    private getOptions(program: ts.Program): CompilerOptions {
+        const options = program.getCompilerOptions() as CompilerOptions;
+
+        // Make options case-insenstive
+        if (options.luaTarget) {
+            options.luaTarget = options.luaTarget.toLowerCase() as LuaTarget;
+        }
+        if (options.luaLibImport) {
+            options.luaLibImport = options.luaLibImport.toLocaleLowerCase() as LuaLibImportKind;
+        }
+
+        return options;
+    }
+
     private reportErrors(): number {
         // Get all diagnostics, ignore unsupported extension
         const diagnostics = ts.getPreEmitDiagnostics(this.program).filter(diag => diag.code !== 6054);

diff --git a/test/src/util.ts b/test/src/util.ts
@@ -76,7 +76,8 @@ export function expectCodeEqual(code1: string, code2: string): void {
 
 // Get a mock transformer to use for testing
 export function makeTestTransformer(target: LuaTarget = LuaTarget.Lua53): LuaTransformer {
-    return new LuaTransformer(ts.createProgram([], {luaTarget: target}));
+    const options = {luaTarget: target};
+    return new LuaTransformer(ts.createProgram([], options), options);
 }
 
 export function transpileAndExecute(

diff --git a/test/unit/assignmentDestructuring.spec.ts b/test/unit/assignmentDestructuring.spec.ts
@@ -1,5 +1,5 @@
 import { Expect, Test, TestCase } from "alsatian";
-import { LuaTarget } from "../../src/CompilerOptions";
+import { LuaTarget, LuaLibImportKind } from "../../src/CompilerOptions";
 import * as util from "../src/util";
 
 export class AssignmentDestructuringTests {
@@ -12,7 +12,7 @@ export class AssignmentDestructuringTests {
     public assignmentDestructuring51(): void {
         // Transpile
         const lua = util.transpileString(
-            this.assignmentDestruturingTs, {luaTarget: LuaTarget.Lua51, luaLibImport: "none"}
+            this.assignmentDestruturingTs, {luaTarget: LuaTarget.Lua51, luaLibImport: LuaLibImportKind.None}
         );
         // Assert
         Expect(lua).toBe(`local a, b = unpack(myFunc());`);
@@ -22,7 +22,7 @@ export class AssignmentDestructuringTests {
     public tupleDestructing52(): void {
         // Transpile
         const lua = util.transpileString(
-            this.assignmentDestruturingTs, {luaTarget: LuaTarget.Lua52, luaLibImport: "none"}
+            this.assignmentDestruturingTs, {luaTarget: LuaTarget.Lua52, luaLibImport: LuaLibImportKind.None}
         );
         // Assert
         Expect(lua).toBe(`local a, b = table.unpack(myFunc());`);
@@ -32,7 +32,7 @@ export class AssignmentDestructuringTests {
     public assignmentDestructuringJIT(): void {
         // Transpile
         const lua = util.transpileString(
-            this.assignmentDestruturingTs, {luaTarget: LuaTarget.LuaJIT, luaLibImport: "none"}
+            this.assignmentDestruturingTs, {luaTarget: LuaTarget.LuaJIT, luaLibImport: LuaLibImportKind.None}
         );
         // Assert
         Expect(lua).toBe(`local a, b = unpack(myFunc());`);

diff --git a/test/unit/compiler/configuration/options.spec.ts b/test/unit/compiler/configuration/options.spec.ts
@@ -0,0 +1,29 @@
+import { Expect, Test, TestCase } from "alsatian";
+
+import * as util from "../../../src/util";
+import { LuaTarget, LuaLibImportKind } from "../../../../src/CompilerOptions";
+
+export class ObjectLiteralTests
+{
+    @TestCase(LuaTarget.LuaJIT)
+    @TestCase("jit")
+    @TestCase("JiT")
+    @Test("Options LuaTarget case-insensitive")
+    public luaTargetCaseInsensitive(target: string): void {
+        const options = {LuaTarget: target};
+        const result = util.transpileString("~a", options);
+
+        Expect(result).toBe("bit.bnot(a);");
+    }
+
+    @TestCase(LuaLibImportKind.None)
+    @TestCase("none")
+    @TestCase("NoNe")
+    @Test("Options LuaLibImport case-insensitive")
+    public luaLibImportCaseInsensitive(importKind: string): void {
+        const options = {LuaLibImportKind: importKind};
+        const result = util.transpileString("const a = new Map<string, string>();", options);
+
+        Expect(result).toBe("local a = Map.new(true);");
+    }
+}
diff --git a/test/unit/expressions.spec.ts b/test/unit/expressions.spec.ts
@@ -1,6 +1,6 @@
 import { Expect, Test, TestCase } from "alsatian";
 import { TranspileError } from "../../src/TranspileError";
-import { LuaTarget } from "../../src/CompilerOptions";
+import { LuaTarget, LuaLibImportKind } from "../../src/CompilerOptions";
 
 import * as ts from "typescript";
 import * as util from "../src/util";
@@ -100,7 +100,7 @@ export class ExpressionTests {
     @Test("Bitop [5.1]")
     public bitOperatorOverride51(input: string, lua: string): void {
         // Bit operations not supported in 5.1, expect an exception
-        Expect(() => util.transpileString(input, { luaTarget: LuaTarget.Lua51, luaLibImport: "none" }))
+        Expect(() => util.transpileString(input, { luaTarget: LuaTarget.Lua51, luaLibImport: LuaLibImportKind.None }))
             .toThrow();
     }
 
@@ -119,7 +119,8 @@ export class ExpressionTests {
     @TestCase("a>>>=b", "a = bit.arshift(a, b);")
     @Test("Bitop [JIT]")
     public bitOperatorOverrideJIT(input: string, lua: string): void {
-        Expect(util.transpileString(input, { luaTarget: LuaTarget.LuaJIT, luaLibImport: "none" })).toBe(lua);
+        const options = { luaTarget: LuaTarget.LuaJIT, luaLibImport: LuaLibImportKind.None };
+        Expect(util.transpileString(input, options)).toBe(lua);
     }
 
     @TestCase("~a", "bit32.bnot(a);")
@@ -137,7 +138,8 @@ export class ExpressionTests {
     @TestCase("a>>>=b", "a = bit32.arshift(a, b);")
     @Test("Bitop [5.2]")
     public bitOperatorOverride52(input: string, lua: string): void {
-        Expect(util.transpileString(input, { luaTarget: LuaTarget.Lua52, luaLibImport: "none" })).toBe(lua);
+        const options = { luaTarget: LuaTarget.Lua52, luaLibImport: LuaLibImportKind.None };
+        Expect(util.transpileString(input, options)).toBe(lua);
     }
 
     @TestCase("~a", "~a;")
@@ -153,14 +155,15 @@ export class ExpressionTests {
     @TestCase("a>>=b", "a = a >> b;")
     @Test("Bitop [5.3]")
     public bitOperatorOverride53(input: string, lua: string): void {
-        Expect(util.transpileString(input, { luaTarget: LuaTarget.Lua53, luaLibImport: "none" })).toBe(lua);
+        const options = { luaTarget: LuaTarget.Lua53, luaLibImport: LuaLibImportKind.None };
+        Expect(util.transpileString(input, options)).toBe(lua);
     }
 
     @TestCase("a>>>b")
     @TestCase("a>>>=b")
     @Test("Unsupported bitop 5.3")
     public bitOperatorOverride53Unsupported(input: string): void {
-        Expect(() => util.transpileString(input, { luaTarget: LuaTarget.Lua53, luaLibImport: "none" }))
+        Expect(() => util.transpileString(input, { luaTarget: LuaTarget.Lua53, luaLibImport: LuaLibImportKind.None }))
             .toThrowError(TranspileError, "Bitwise >>> operator is/are not supported for target Lua 5.3.");
     }
 

diff --git a/test/unit/spreadElement.spec.ts b/test/unit/spreadElement.spec.ts
@@ -1,6 +1,6 @@
 import { Expect, Test, TestCase } from "alsatian";
 
-import { LuaTarget } from "../../src/CompilerOptions";
+import { LuaTarget, LuaLibImportKind } from "../../src/CompilerOptions";
 import * as util from "../src/util";
 
 export class SpreadElementTest {
@@ -26,19 +26,24 @@ export class SpreadElementTest {
     @Test("Spread Element Lua 5.2")
     public spreadElement52(): void
     {
-        const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua52, luaLibImport: "none"});
+        const options = {luaTarget: LuaTarget.Lua52, luaLibImport: LuaLibImportKind.None};
+        const lua = util.transpileString(`[...[0, 1, 2]]`, options);
         Expect(lua).toBe("{table.unpack({0, 1, 2})};");
     }
-     @Test("Spread Element Lua 5.3")
+
+    @Test("Spread Element Lua 5.3")
     public spreadElement53(): void
     {
-        const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua53, luaLibImport: "none"});
+        const options = {luaTarget: LuaTarget.Lua53, luaLibImport: LuaLibImportKind.None};
+        const lua = util.transpileString(`[...[0, 1, 2]]`, options);
         Expect(lua).toBe("{table.unpack({0, 1, 2})};");
     }
-     @Test("Spread Element Lua JIT")
+
+    @Test("Spread Element Lua JIT")
     public spreadElementJIT(): void
     {
-        const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.LuaJIT, luaLibImport: "none"});
+        const options = {luaTarget: "JiT" as LuaTarget, luaLibImport: LuaLibImportKind.None};
+        const lua = util.transpileString(`[...[0, 1, 2]]`, options);
         Expect(lua).toBe("{unpack({0, 1, 2})};");
     }
 }