Addded NS Transformer

lolleko · lolleko · commit 7c04fa770ac3 · 2018-11-27T17:35:56.000+01:00
diff --git a/src/TransformHelper.ts b/src/TransformHelper.ts
@@ -2,11 +2,9 @@ import * as ts from "typescript";
 
 export class TransformHelper {
     // Helper to create simple lua variable statement;
-    public static createLuaVariableStatement(
-        identifier: ts.Identifier,
-        expression: ts.Expression,
-        typeNode?: ts.TypeNode
-    ): ts.VariableStatement {
+    public static createLuaVariableStatement(identifier: ts.Identifier,
+                                             expression?: ts.Expression,
+                                             typeNode?: ts.TypeNode): ts.VariableStatement {
         const declaration = ts.createVariableDeclaration(identifier, typeNode, expression);
         const statement = ts.createVariableStatement([], ts.createVariableDeclarationList([declaration]));
         return statement;
diff --git a/src/Transformer.ts b/src/Transformer.ts
@@ -12,6 +12,9 @@ export class LuaTransformer {
     private options: CompilerOptions;
     private context: ts.TransformationContext;
     private sourceFile: ts.SourceFile;
+    private isModule: boolean;
+
+    private currentNamespace: ts.ModuleDeclaration;
 
     constructor(checker: ts.TypeChecker, options: CompilerOptions) {
         this.checker = checker;
@@ -20,6 +23,7 @@ export class LuaTransformer {
 
     public transform(node: ts.SourceFile): ts.SourceFile {
         this.sourceFile = node;
+        this.isModule = tsHelper.isFileModule(node);
         return ts
             .transform(node,
                        [(ctx: ts.TransformationContext) => {
@@ -232,8 +236,44 @@ export class LuaTransformer {
         if (decorators.has(DecoratorKind.Phantom) && node.body) {
             return node.body;
         }
-        // TODO actual transpilation
-        return node;
+
+        const result: ts.Node[] = [];
+
+        let declarationNameExpression: ts.Expression;
+        if (this.currentNamespace) {
+            const declarationNameExpression =
+                ts.createPropertyAccess(this.currentNamespace.name, node.name as ts.Identifier);
+            const declarationAssignment = ts.createAssignment(
+                declarationNameExpression, ts.createLogicalOr(declarationNameExpression, ts.createObjectLiteral()));
+
+            result.push(declarationAssignment);
+            // outerNS.innerNS = outerNS.innerNS or {};
+            // local innerNS = outerNS.innerNS
+        } else if (this.isModule && (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export)) {
+            declarationNameExpression =
+                ts.createPropertyAccess(ts.createIdentifier("export"), node.name as ts.Identifier);
+            // exports.NS = exports.NS or {}
+            // local NS = exports.NS
+        } else {
+            declarationNameExpression = node.name;
+            // NS = NS or {}
+            // local NS = NS
+        }
+
+        // Set current namespace for nested NS
+        // Keep previous currentNS to reset after block transpilation
+        const previousNamespace = this.currentNamespace;
+        this.currentNamespace = node;
+
+        // Transform moduleblock to block and transform it
+        if (ts.isModuleBlock(node.body)) {
+            const bodyBlock = this.visitBlock(ts.createBlock(node.body.statements)) as ts.Block;
+            result.push(bodyBlock);
+        }
+
+        this.currentNamespace = previousNamespace;
+
+        return result;
     }
     public visitEnumDeclaration(node: ts.EnumDeclaration): ts.VisitResult<ts.EnumDeclaration> {
         return node;
@@ -424,5 +464,4 @@ export class LuaTransformer {
     private pathToLuaRequirePath(filePath: string): string {
         return filePath.replace(new RegExp("\\\\|\/", "g"), ".");
     }
-
 }
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -267,8 +267,6 @@ export abstract class LuaTranspiler {
         switch (node.kind) {
             case ts.SyntaxKind.ClassDeclaration:
                 return this.transpileClass(node as ts.ClassDeclaration);
-            case ts.SyntaxKind.ModuleDeclaration:
-                return this.transpileNamespace(node as ts.ModuleDeclaration);
             case ts.SyntaxKind.ModuleBlock:
                 return this.transpileBlock(node as ts.Block);
             case ts.SyntaxKind.EnumDeclaration:
@@ -319,36 +317,6 @@ export abstract class LuaTranspiler {
         return `__TS__${func}(${params.join(", ")})`;
     }
 
-    public transpileNamespace(node: ts.ModuleDeclaration): string {
-        const decorators = tsHelper.getCustomDecorators(this.checker.getTypeAtLocation(node), this.checker);
-        // If phantom namespace just transpile the body as normal
-        if (decorators.has(DecoratorKind.Phantom) && node.body) {
-            return this.transpileNode(node.body);
-        }
-
-        const defName = this.definitionName(node.name.text);
-        // Initialize to pre-existing export if one exists
-        const prefix = (this.namespace.length === 0 && this.isModule &&
-            (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export)) ? `exports.${node.name.text} or ` : "";
-        let result =
-            this.indent +
-            this.accessPrefix(node) +
-            `${node.name.text} = ${prefix}${node.name.text} or {}\n`;
-
-        this.pushExport(node.name.text, node);
-        // Create closure
-        result += this.indent + "do\n";
-        this.pushIndent();
-        this.namespace.push(node.name.text);
-        if (node.body) {
-            result += this.transpileNode(node.body);
-        }
-        this.namespace.pop();
-        this.popIndent();
-        result += this.indent + "end\n";
-        return result;
-    }
-
     public transpileEnum(node: ts.EnumDeclaration): string {
         const type = this.checker.getTypeAtLocation(node);
 
