From eca1be45be3ad2f0b298d8b04fc89e5cdcad651a Mon Sep 17 00:00:00 2001
From: Perryvw <perry.wesel@gmail.com>
Date: Wed, 13 Nov 2019 23:07:54 +0100
Subject: [PATCH] Playing with initial lua transformer setup

---
 src/BundlerTransformer.ts                     | 30 ++++++++++++++++++
 src/CustomLuaTransformers.ts                  | 31 +++++++++++++++++++
 ...ransformers.ts => CustomTSTransformers.ts} |  2 +-
 src/Transpile.ts                              | 17 ++++++++--
 4 files changed, 77 insertions(+), 3 deletions(-)
 create mode 100644 src/BundlerTransformer.ts
 create mode 100644 src/CustomLuaTransformers.ts
 rename src/{TSTransformers.ts => CustomTSTransformers.ts} (99%)

diff --git a/src/BundlerTransformer.ts b/src/BundlerTransformer.ts
new file mode 100644
index 000000000..6b345b1c2
--- /dev/null
+++ b/src/BundlerTransformer.ts
@@ -0,0 +1,30 @@
+import { TranspiledFile } from "./Transpile";
+import { LuaProjectTransformer } from "./CustomLuaTransformers";
+import { createBlock, Statement } from "./LuaAST";
+
+type BundlerTransformerFactory = (outFile: string) => LuaProjectTransformer;
+
+function notUndefined<T>(value: T | undefined): value is T {
+    return value !== undefined;
+}
+
+// TODO: Implement correctly, this is just a PoC!
+export const bundlerTransformer: BundlerTransformerFactory = (outFile: string) => (projectFiles: TranspiledFile[]) => {
+    const bundledFile: TranspiledFile = {
+        fileName: outFile,
+        declaration: projectFiles
+            .map(f => f.declaration)
+            .filter(notUndefined)
+            .join("\n"),
+        luaAst: createBlock(
+            ([] as Statement[]).concat(
+                ...projectFiles
+                    .map(f => f.luaAst)
+                    .filter(notUndefined)
+                    .map(ast => ast.statements)
+            )
+        ),
+
+    };
+    return [bundledFile];
+};
diff --git a/src/CustomLuaTransformers.ts b/src/CustomLuaTransformers.ts
new file mode 100644
index 000000000..29dc19ba5
--- /dev/null
+++ b/src/CustomLuaTransformers.ts
@@ -0,0 +1,31 @@
+import { Diagnostic } from "typescript";
+import { CompilerOptions } from "./CompilerOptions";
+import { TranspiledFile } from "./Transpile";
+import { bundlerTransformer } from "./BundlerTransformer";
+
+export interface CustomLuaTransformers {
+    /** Custom transformers to evaluate before printing */
+    before: LuaProjectTransformer[];
+    /** Custom transformers to evaluate after printing */
+    after: LuaProjectTransformer[];
+}
+
+export type LuaProjectTransformer = (projectFiles: TranspiledFile[]) => TranspiledFile[];
+
+export function getCustomLuaTransformers(
+    options: CompilerOptions,
+    diagnostics: Diagnostic[]
+    //customTransformers: ts.CustomTransformers,
+): CustomLuaTransformers {
+    const beforePrinting: LuaProjectTransformer[] = [];
+    if (options.outFile) {
+        beforePrinting.push(bundlerTransformer(options.outFile));
+    }
+
+    const afterPrinting: LuaProjectTransformer[] = [];
+
+    return {
+        before: beforePrinting,
+        after: afterPrinting,
+    };
+}
diff --git a/src/TSTransformers.ts b/src/CustomTSTransformers.ts
similarity index 99%
rename from src/TSTransformers.ts
rename to src/CustomTSTransformers.ts
index 710e3ac0e..4fdb9dc90 100644
--- a/src/TSTransformers.ts
+++ b/src/CustomTSTransformers.ts
@@ -6,7 +6,7 @@ import { CompilerOptions, TransformerImport } from "./CompilerOptions";
 import * as diagnosticFactories from "./diagnostics";
 import { noImplicitSelfTransformer } from "./NoImplicitSelfTransformer";
 
-export function getCustomTransformers(
+export function getCustomTSTransformers(
     program: ts.Program,
     diagnostics: ts.Diagnostic[],
     customTransformers: ts.CustomTransformers,
diff --git a/src/Transpile.ts b/src/Transpile.ts
index 28a6282a9..ff92cc5a1 100644
--- a/src/Transpile.ts
+++ b/src/Transpile.ts
@@ -5,7 +5,8 @@ import { Block } from "./LuaAST";
 import { LuaPrinter } from "./LuaPrinter";
 import { LuaTransformer } from "./LuaTransformer";
 import { TranspileError } from "./TranspileError";
-import { getCustomTransformers } from "./TSTransformers";
+import { getCustomTSTransformers } from "./CustomTSTransformers";
+import { getCustomLuaTransformers } from "./CustomLuaTransformers";
 
 export interface TranspiledFile {
     fileName: string;
@@ -97,7 +98,7 @@ export function transpile({
         }
     };
 
-    const transformers = getCustomTransformers(program, diagnostics, customTransformers, processSourceFile);
+    const transformers = getCustomTSTransformers(program, diagnostics, customTransformers, processSourceFile);
 
     const writeFile: ts.WriteFileCallback = (fileName, data, _bom, _onError, sourceFiles = []) => {
         for (const sourceFile of sourceFiles) {
@@ -120,6 +121,13 @@ export function transpile({
     const oldNoEmit = options.noEmit;
     options.noEmit = false;
 
+    const luaTransformers = getCustomLuaTransformers(options, diagnostics);
+
+    // TODO: Make sure source files have been transformed at this point, but not printed
+    for (const luaTransformer of luaTransformers.before) {
+        transpiledFiles = luaTransformer(transpiledFiles);
+    }
+
     if (targetSourceFiles) {
         for (const file of targetSourceFiles) {
             if (isEmittableJsonFile(file)) {
@@ -144,5 +152,10 @@ export function transpile({
         transpiledFiles = [];
     }
 
+    // TODO: Make sure source files have been transformed AND printed at this point
+    for (const luaTransformer of luaTransformers.after) {
+        transpiledFiles = luaTransformer(transpiledFiles);
+    }
+
     return { diagnostics, transpiledFiles };
 }