@bikky/compiler 0.0.8 → 0.0.9

package/Transformers/MacroTransformer.js

@@ -1,282 +1,283 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// transformer1-module
-const ts = require("typescript");
-//This class should be able to do a few things:
-// Import macros from other files.
-// Copy macro AST
-// Insert macro AST to the destination location (inlining the macro).
-// Resolve variable names to the name of the provided variable.
-// Not require special (complex) syntax in the macro creation.
-class MacroTransformer {
-    constructor() {
-        this.RegisteredMacros = new Map();
-        this.DeclarationName = "MACRO";
-        this.printer = ts.createPrinter();
-    }
-    logError(node, error) {
-        if (!node || !node.getSourceFile()) {
-            console.error("Why are we here?");
-            return;
-        }
-        var source = ts.isSourceFile(node) ? node : node.getSourceFile();
-        var pos = source.getLineAndCharacterOfPosition(node.pos);
-        console.error(`${source.fileName}(${pos.line},${pos.character}):`, error);
-        // This can cause the compiler to stop, but we're not using it because the above will allow
-        // us to go to the right location in the file. And we probably want to return what we can if
-        // there's an error since that's how the rest of typescript works.
-        //ts.createThrow(ts.createStringLiteral("Compiler Error."));
-        return;
-    }
-    printNode(node, sourceFile) {
-        return this.printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
-    }
-    printNodeFirstLine(node, sourceFile) {
-        var code = this.printNode(node, node.getSourceFile());
-        //space matches tab.
-        code = code.replace(/^ *{? *\r\n?/, "");
-        return code.replace(/\r\n.*/gi, "");
-    }
-    CrawlExpressionTree(node) {
-        //Run twice, we hoist macro declarations.
-        node = ts.visitNode(node, this.FindMacroDeclaration.bind(this));
-        return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
-    }
-    FindMacroDeclaration(node) {
-        if (ts.isVariableStatement(node)) {
-            //This statement has potential to contain a MACRO declaration.
-            //Support for comma separated declarations.
-            for (var declaration of node.declarationList.declarations) {
-                //If this variable is initialised, and it's initialised with a function call check to see
-                // if the function's name is MACRO (which is our custom buzzword).
-                if (declaration.initializer
-                    && ts.isCallExpression(declaration.initializer)
-                    && ts.isIdentifier(declaration.initializer.expression)
-                    && declaration.initializer.expression.text === this.DeclarationName) {
-                    //This is the name of the variable that the macro's being assigned to.
-                    var name = declaration.name;
-                    //Macros must be identifiers (normal variables, not symbols and not array unwraps).
-                    if (!ts.isIdentifier(name)) {
-                        this.logError(declaration, "Macros must be declared as using normal identifiers, symbols and array unwraps are unsupported.");
-                        return node;
-                    }
-                    if (declaration.initializer.arguments.length == 0) {
-                        this.logError(declaration, "When declaring a macro a function must be supplied as the first parameter.");
-                        return node;
-                    }
-                    if (declaration.initializer.arguments.length > 1) {
-                        this.logError(declaration, "Macro declaration only takes one parameter.");
-                        return node;
-                    }
-                    var value = declaration.initializer.arguments[0];
-                    this.RegisteredMacros.set(name.text, value);
-                    console.log("Registering macro", name.text);
-                    //Now that we've stored the macro code for later use, we need to delete it from the file. 
-                    //Todo: this creates an unnecessary semicolon.
-                    return ts.createEmptyStatement();
-                }
-            }
-        }
-        node = ts.visitEachChild(node, this.FindMacroDeclaration.bind(this), this.context) || node;
-        return node;
-    }
-    SearchForMacroUseStatement(node) {
-        if (ts.isBlock(node) || ts.isSourceFile(node) || ts.isCaseBlock(node)) {
-            //console.log("Block:", this.printNodeFirstLine(node, node.getSourceFile()));
-            return ts.visitEachChild(node, this.FindMacroUsage.bind(this), this.context);
-        }
-        else if (ts.isFunctionDeclaration(node)) {
-            var body = ts.visitEachChild(node.body, this.FindMacroUsage.bind(this), this.context);
-            let foo = ts.updateFunctionDeclaration(node, node.decorators, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body);
-            //if (foo.name) {
-            //	console.log("Function:", this.printNode(foo.name, node.getSourceFile()));
-            //}
-            return foo;
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            var body = ts.visitEachChild(node.body, this.FindMacroUsage.bind(this), this.context);
-            let foo = ts.updateMethod(node, node.decorators, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, body);
-            //console.log("Method:", this.printNode(foo.name, node.getSourceFile()));
-            return foo;
-        }
-        else if (ts.isIfStatement(node)) {
-            //console.log("IF:", this.printNode(node, node.getSourceFile()));
-            var thenS = ts.visitNode(node.thenStatement, this.SearchForMacroUseStatement.bind(this));
-            var elseS = node.elseStatement ? ts.visitNode(node.elseStatement, this.SearchForMacroUseStatement.bind(this)) : undefined;
-            return ts.updateIf(node, node.expression, thenS, elseS);
-        }
-        else {
-            return ts.visitEachChild(node, this.SearchForMacroUseStatement.bind(this), this.context);
-        }
-    }
-    isBlocky(node) {
-        return ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isIfStatement(node);
-    }
-    FindMacroUsage(node) {
-        if (this.isBlocky(node)) {
-            return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
-        }
-        var MACARONY = false;
-        var context = undefined;
-        var call = undefined;
-        //How to do this:
-        //Recurse through statement to see if it has a macro expression.
-        function SpyMacro(node) {
-            //If there's a new block in here we bail, otherwise we'd put the macro scoping in the wrong scoping level.
-            if (ts.isBlock(node) || ts.isCaseBlock(node) || this.isBlocky(node)) {
-                return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
-            }
-            if (ts.isCallExpression(node)
-                && ts.isPropertyAccessExpression(node.expression)
-                && this.RegisteredMacros.has(node.expression.name.text)) {
-                MACARONY = true;
-                context = node.expression.expression;
-                call = node;
-                //console.log("FOUND MACRO USAGE!", node.expression.name.text);
-            }
-            if (ts.isCallExpression(node) &&
-                ts.isIdentifier(node.expression) &&
-                this.RegisteredMacros.has(node.expression.text)) {
-                MACARONY = true;
-                call = node;
-            }
-            return ts.visitEachChild(node, SpyMacro.bind(this), this.context);
-        }
-        ts.visitEachChild(node, SpyMacro.bind(this), this.context);
-        if (MACARONY) {
-            return this.InsertMacro(node, context, call);
-        }
-        else {
-            return node;
-        }
-    }
-    //"context" is the thing before the dot when the macro is called, might be undefined. 
-    //"context" is present if you call the macro like so: context.MACRO().
-    //Call expression is the node that represents the MACRO() part of the statement.
-    InsertMacro(statement, context, macroCall) {
-        var block = [];
-        var macro;
-        var macroName;
-        if (ts.isIdentifier(macroCall.expression)) {
-            macroName = macroCall.expression.text;
-        }
-        else if (ts.isPropertyAccessExpression(macroCall.expression)) {
-            macroName = macroCall.expression.name.text;
-        }
-        if (macroName) {
-            macro = this.RegisteredMacros.get(macroName);
-        }
-        if (!macroName || !macro) {
-            this.logError(statement, "Unspecified error in macro expansion.");
-            return statement;
-        }
-        //console.log("Putting", macroName, "in to place:", statement.getText());
-        //Map macro parameters to the arguments (replace all instances of the parameter with the argument's expression).
-        //Replacing identifiers with nodes because it can be an unnamed expression (lambda or 3 + 5).
-        var parameters = new Map();
-        var parameterOffset = 0;
-        for (var i = 0; i + parameterOffset < macro.parameters.length; i++) {
-            var parameter = macro.parameters[i + parameterOffset];
-            //Detect and skip "this" parameter
-            if (ts.isParameter(parameter) && parameter.name.getText() == "this") {
-                parameterOffset = 1;
-                //If "this" is the only parameter then don't do the rest of the loop.
-                if (!(i + parameterOffset < macro.parameters.length)) {
-                    break;
-                }
-                parameter = macro.parameters[i + parameterOffset];
-            }
-            var argument = macroCall.arguments[i];
-            if (typeof argument === "undefined") {
-                if (typeof parameter.questionToken === "undefined") {
-                    this.logError(parameter, `Failure to specify non-optional argument to macro ${macroName}.`);
-                    return statement;
-                    //throw new Error("Failure to specify non-optional argument to macro.");
-                }
-                else {
-                    //Probably use this instead, because it's garenteed to be unique.
-                    //ts.getGeneratedNameForNode
-                    var name = parameter.name.getText();
-                    //This is "let param;" for optional variables that weren't done.
-                    var ver = ts.createVariableStatement([], ts.createVariableDeclarationList([ts.createVariableDeclaration(name)], ts.NodeFlags.Let));
-                    block.push(ver);
-                    parameters.set(name, ts.createIdentifier(name));
-                }
-            }
-            else {
-                parameters.set(parameter.name.getText(), argument);
-            }
-        }
-        //Macros can be multiline!
-        //So we need to insert the macro into the appropriate place in the block, and then duplicate expression
-        // wherever return shows up in the macro (or on the next line if it doesn't? or maybe error...). 
-        var body = (macro.body);
-        //Put the macro's result in the calling expression in place of the macro call.
-        var PutResultInExpression = (result) => {
-            return function IterateResult(node) {
-                if (ts.isCallExpression(node)
-                    && ts.isPropertyAccessExpression(node.expression)
-                    && node.expression.name.text == macroName
-                    || ts.isCallExpression(node)
-                        && ts.isIdentifier(node.expression)
-                        && node.expression.text == macroName) {
-                    //replace with stuff after return statement.
-                    return ts.visitNode(result.expression, ReplaceStuffInMacro.bind(this));
-                }
-                return ts.visitEachChild(node, IterateResult.bind(this), this.context);
-            }.bind(this);
-        };
-        function CopyAsIs(node) {
-            return ts.visitEachChild(node, CopyAsIs.bind(this), this.context);
-        }
-        function ReplaceStuffInMacro(node) {
-            if (ts.isReturnStatement(node)) {
-                return ts.visitEachChild(statement, PutResultInExpression(node), this.context);
-            }
-            if (ts.isPropertyAccessExpression(node) && (node.expression.kind == ts.SyntaxKind.ThisType || node.expression.kind == ts.SyntaxKind.ThisKeyword)) {
-                if (!context) {
-                    this.logError(node, "Macro can only be executed as a property accessor (value.MACRO) but here is not, this causes an error. MACRO.bind is not supported use value.MACRO instead.");
-                    return node;
-                }
-                //If this is referenced then replace it with the stuff before the . when the macro is called.
-                return ts.createPropertyAccess(context, node.name.text);
-                //return ts.visitEachChild(context, Inplace.bind(this), this.context);
-            }
-            if (ts.isIdentifier(node) && parameters.has(node.text)) {
-                //If a parameter is referenced replace it with the argument provided in macro use.
-                return ts.visitNode(parameters.get(node.text), CopyAsIs.bind(this));
-            }
-            return ts.visitEachChild(node, ReplaceStuffInMacro.bind(this), this.context);
-        }
-        //unroll macro and then replace all return statements with expression.
-        for (var expression of body.statements) {
-            block.push(ts.visitNode(expression, ReplaceStuffInMacro.bind(this)));
-        }
-        var result = ts.createBlock(block);
-        return result;
-    }
-}
-console.log("MACROS ENABLED");
-//Initiating the transformer here is a hodge-podge solution to resolving transforms supplied in other files.
-// We probably need to do a proper solution that involves aliasing the macro's name to whatever the import is called, and removing
-// the import statement if the only thing that's imported is macros. On second thought that last part is really hard so let's not
-// do that.
-var transformer = new MacroTransformer();
-function default_1(program, pluginOptions) {
-    return (context) => {
-        transformer.context = context;
-        return (sourceFile) => {
-            console.log("HERE!");
-            // function visitor(node: ts.Node): ts.Node {
-            // 	// if (ts.isCallExpression(node)) {
-            // 	//     return ts.createLiteral('call');
-            // 	// }
-            // 	return ts.visitEachChild(node, visitor, context);
-            // }
-            return transformer.CrawlExpressionTree(sourceFile);
-            // return ts.visitEachChild(sourceFile, visitor, context);
-        };
-    };
-}
-exports.default = default_1;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// transformer1-module
+const ts = require("typescript");
+const ASTBuilder_1 = require("../Source/ASTBuilder");
+//This class should be able to do a few things:
+// Import macros from other files.
+// Copy macro AST
+// Insert macro AST to the destination location (inlining the macro).
+// Resolve variable names to the name of the provided variable.
+// Not require special (complex) syntax in the macro creation.
+class MacroTransformer {
+    constructor() {
+        this.RegisteredMacros = new Map();
+        this.DeclarationName = "MACRO";
+        this.printer = ts.createPrinter();
+    }
+    logError(node, error) {
+        if (!node || !node.getSourceFile()) {
+            console.error("Why are we here?");
+            return;
+        }
+        var source = ts.isSourceFile(node) ? node : node.getSourceFile();
+        var pos = source.getLineAndCharacterOfPosition(node.pos);
+        console.error(`${source.fileName}(${pos.line},${pos.character}):`, error);
+        // This can cause the compiler to stop, but we're not using it because the above will allow
+        // us to go to the right location in the file. And we probably want to return what we can if
+        // there's an error since that's how the rest of typescript works.
+        //ts.createThrow(ts.createStringLiteral("Compiler Error."));
+        return;
+    }
+    printNode(node, sourceFile) {
+        return this.printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    }
+    printNodeFirstLine(node, sourceFile) {
+        var code = this.printNode(node, node.getSourceFile());
+        //space matches tab.
+        code = code.replace(/^ *{? *\r\n?/, "");
+        return code.replace(/\r\n.*/gi, "");
+    }
+    CrawlExpressionTree(node) {
+        //Run twice, we hoist macro declarations.
+        node = ts.visitNode(node, this.FindMacroDeclaration.bind(this));
+        return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
+    }
+    FindMacroDeclaration(node) {
+        if (ts.isVariableStatement(node)) {
+            //This statement has potential to contain a MACRO declaration.
+            //Support for comma separated declarations.
+            for (var declaration of node.declarationList.declarations) {
+                //If this variable is initialised, and it's initialised with a function call check to see
+                // if the function's name is MACRO (which is our custom buzzword).
+                if (declaration.initializer
+                    && ts.isCallExpression(declaration.initializer)
+                    && ts.isIdentifier(declaration.initializer.expression)
+                    && declaration.initializer.expression.text === this.DeclarationName) {
+                    //This is the name of the variable that the macro's being assigned to.
+                    var name = declaration.name;
+                    //Macros must be identifiers (normal variables, not symbols and not array unwraps).
+                    if (!ts.isIdentifier(name)) {
+                        this.logError(declaration, "Macros must be declared as using normal identifiers, symbols and array unwraps are unsupported.");
+                        return node;
+                    }
+                    if (declaration.initializer.arguments.length == 0) {
+                        this.logError(declaration, "When declaring a macro a function must be supplied as the first parameter.");
+                        return node;
+                    }
+                    if (declaration.initializer.arguments.length > 1) {
+                        this.logError(declaration, "Macro declaration only takes one parameter.");
+                        return node;
+                    }
+                    var value = declaration.initializer.arguments[0];
+                    this.RegisteredMacros.set(name.text, value);
+                    console.log("Registering macro", name.text);
+                    //Now that we've stored the macro code for later use, we need to delete it from the file. 
+                    //Todo: this creates an unnecessary semicolon.
+                    return ts.factory.createEmptyStatement();
+                }
+            }
+        }
+        node = ts.visitEachChild(node, this.FindMacroDeclaration.bind(this), this.context) || node;
+        return node;
+    }
+    SearchForMacroUseStatement(node) {
+        if (ts.isBlock(node) || ts.isSourceFile(node) || ts.isCaseBlock(node)) {
+            //console.log("Block:", this.printNodeFirstLine(node, node.getSourceFile()));
+            return ts.visitEachChild(node, this.FindMacroUsage.bind(this), this.context);
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            var body = ts.visitEachChild(node.body, this.FindMacroUsage.bind(this), this.context);
+            let foo = ts.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body);
+            //if (foo.name) {
+            //	console.log("Function:", this.printNode(foo.name, node.getSourceFile()));
+            //}
+            return foo;
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            var body = ts.visitEachChild(node.body, this.FindMacroUsage.bind(this), this.context);
+            let foo = ts.factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, body);
+            //console.log("Method:", this.printNode(foo.name, node.getSourceFile()));
+            return foo;
+        }
+        else if (ts.isIfStatement(node)) {
+            //console.log("IF:", this.printNode(node, node.getSourceFile()));
+            var thenS = ts.visitNode(node.thenStatement, this.SearchForMacroUseStatement.bind(this));
+            var elseS = node.elseStatement ? ts.visitNode(node.elseStatement, this.SearchForMacroUseStatement.bind(this)) : undefined;
+            return ts.factory.updateIfStatement(node, node.expression, thenS, elseS);
+        }
+        else {
+            return ts.visitEachChild(node, this.SearchForMacroUseStatement.bind(this), this.context);
+        }
+    }
+    isBlocky(node) {
+        return ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isIfStatement(node);
+    }
+    FindMacroUsage(node) {
+        if (this.isBlocky(node)) {
+            return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
+        }
+        var MACARONY = false;
+        var context = undefined;
+        var call = undefined;
+        //How to do this:
+        //Recurse through statement to see if it has a macro expression.
+        function SpyMacro(node) {
+            //If there's a new block in here we bail, otherwise we'd put the macro scoping in the wrong scoping level.
+            if (ts.isBlock(node) || ts.isCaseBlock(node) || this.isBlocky(node)) {
+                return ts.visitNode(node, this.SearchForMacroUseStatement.bind(this));
+            }
+            if (ts.isCallExpression(node)
+                && ts.isPropertyAccessExpression(node.expression)
+                && this.RegisteredMacros.has(node.expression.name.text)) {
+                MACARONY = true;
+                context = node.expression.expression;
+                call = node;
+                //console.log("FOUND MACRO USAGE!", node.expression.name.text);
+            }
+            if (ts.isCallExpression(node) &&
+                ts.isIdentifier(node.expression) &&
+                this.RegisteredMacros.has(node.expression.text)) {
+                MACARONY = true;
+                call = node;
+            }
+            return ts.visitEachChild(node, SpyMacro.bind(this), this.context);
+        }
+        ts.visitEachChild(node, SpyMacro.bind(this), this.context);
+        if (MACARONY) {
+            return this.InsertMacro(node, context, call);
+        }
+        else {
+            return node;
+        }
+    }
+    //"context" is the thing before the dot when the macro is called, might be undefined. 
+    //"context" is present if you call the macro like so: context.MACRO().
+    //Call expression is the node that represents the MACRO() part of the statement.
+    InsertMacro(statement, context, macroCall) {
+        var block = [];
+        var macro;
+        var macroName;
+        if (ts.isIdentifier(macroCall.expression)) {
+            macroName = macroCall.expression.text;
+        }
+        else if (ts.isPropertyAccessExpression(macroCall.expression)) {
+            macroName = macroCall.expression.name.text;
+        }
+        if (macroName) {
+            macro = this.RegisteredMacros.get(macroName);
+        }
+        if (!macroName || !macro) {
+            this.logError(statement, "Unspecified error in macro expansion.");
+            return statement;
+        }
+        //console.log("Putting", macroName, "in to place:", statement.getText());
+        //Map macro parameters to the arguments (replace all instances of the parameter with the argument's expression).
+        //Replacing identifiers with nodes because it can be an unnamed expression (lambda or 3 + 5).
+        var parameters = new Map();
+        var parameterOffset = 0;
+        for (var i = 0; i + parameterOffset < macro.parameters.length; i++) {
+            var parameter = macro.parameters[i + parameterOffset];
+            //Detect and skip "this" parameter
+            if (ts.isParameter(parameter) && parameter.name.getText() == "this") {
+                parameterOffset = 1;
+                //If "this" is the only parameter then don't do the rest of the loop.
+                if (!(i + parameterOffset < macro.parameters.length)) {
+                    break;
+                }
+                parameter = macro.parameters[i + parameterOffset];
+            }
+            var argument = macroCall.arguments[i];
+            if (typeof argument === "undefined") {
+                if (typeof parameter.questionToken === "undefined") {
+                    this.logError(parameter, `Failure to specify non-optional argument to macro ${macroName}.`);
+                    return statement;
+                    //throw new Error("Failure to specify non-optional argument to macro.");
+                }
+                else {
+                    //Probably use this instead, because it's guaranteed to be unique.
+                    //ts.getGeneratedNameForNode
+                    var name = parameter.name.getText();
+                    //This is "let param;" for optional variables that weren't done.
+                    let ver = (0, ASTBuilder_1.LET)(name);
+                    block.push(ver.toAST());
+                    parameters.set(name, (0, ASTBuilder_1.ID)(name).toAST());
+                }
+            }
+            else {
+                parameters.set(parameter.name.getText(), argument);
+            }
+        }
+        //Macros can be multiline!
+        //So we need to insert the macro into the appropriate place in the block, and then duplicate expression
+        // wherever return shows up in the macro (or on the next line if it doesn't? or maybe error...). 
+        var body = (macro.body);
+        //Put the macro's result in the calling expression in place of the macro call.
+        var PutResultInExpression = (result) => {
+            return function IterateResult(node) {
+                if (ts.isCallExpression(node)
+                    && ts.isPropertyAccessExpression(node.expression)
+                    && node.expression.name.text == macroName
+                    || ts.isCallExpression(node)
+                        && ts.isIdentifier(node.expression)
+                        && node.expression.text == macroName) {
+                    //replace with stuff after return statement.
+                    return ts.visitNode(result.expression, ReplaceStuffInMacro.bind(this));
+                }
+                return ts.visitEachChild(node, IterateResult.bind(this), this.context);
+            }.bind(this);
+        };
+        function CopyAsIs(node) {
+            return ts.visitEachChild(node, CopyAsIs.bind(this), this.context);
+        }
+        function ReplaceStuffInMacro(node) {
+            if (ts.isReturnStatement(node)) {
+                return ts.visitEachChild(statement, PutResultInExpression(node), this.context);
+            }
+            if (ts.isPropertyAccessExpression(node) && (node.expression.kind == ts.SyntaxKind.ThisType || node.expression.kind == ts.SyntaxKind.ThisKeyword)) {
+                if (!context) {
+                    this.logError(node, "Macro can only be executed as a property accessor (value.MACRO) but here is not, this causes an error. MACRO.bind is not supported use value.MACRO instead.");
+                    return node;
+                }
+                //If this is referenced then replace it with the stuff before the . when the macro is called.
+                return ts.factory.createPropertyAccessExpression(context, node.name.text);
+                //return ts.visitEachChild(context, Inplace.bind(this), this.context);
+            }
+            if (ts.isIdentifier(node) && parameters.has(node.text)) {
+                //If a parameter is referenced replace it with the argument provided in macro use.
+                return ts.visitNode(parameters.get(node.text), CopyAsIs.bind(this));
+            }
+            return ts.visitEachChild(node, ReplaceStuffInMacro.bind(this), this.context);
+        }
+        //unroll macro and then replace all return statements with expression.
+        for (var expression of body.statements) {
+            block.push(ts.visitNode(expression, ReplaceStuffInMacro.bind(this)));
+        }
+        var result = ts.factory.createBlock(block);
+        return result;
+    }
+}
+console.log("MACROS ENABLED");
+//Initiating the transformer here is a hodge-podge solution to resolving transforms supplied in other files.
+// We probably need to do a proper solution that involves aliasing the macro's name to whatever the import is called, and removing
+// the import statement if the only thing that's imported is macros. On second thought that last part is really hard so let's not
+// do that.
+var transformer = new MacroTransformer();
+function default_1(program, pluginOptions) {
+    return (context) => {
+        transformer.context = context;
+        return (sourceFile) => {
+            console.log("HERE!");
+            // function visitor(node: ts.Node): ts.Node {
+            // 	// if (ts.isCallExpression(node)) {
+            // 	//     return ts.createLiteral('call');
+            // 	// }
+            // 	return ts.visitEachChild(node, visitor, context);
+            // }
+            return transformer.CrawlExpressionTree(sourceFile);
+            // return ts.visitEachChild(sourceFile, visitor, context);
+        };
+    };
+}
+exports.default = default_1;
 //# sourceMappingURL=MacroTransformer.js.map

package/Transformers/MixinTransformer.d.ts

@@ -1,4 +1,3 @@
-import * as ts from "typescript";
-import { SourceFile } from "../Source/ASTHelper.js";
-export default function (program: ts.Program, pluginOptions: {}): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
+import * as ts from "typescript";
+export default function (program: ts.Program, pluginOptions: {}): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.Node;
 //# sourceMappingURL=MixinTransformer.d.ts.map

package/Transformers/MixinTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MixinTransformer.d.ts","sourceRoot":"","sources":["MixinTransformer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAA0G,UAAU,EAAsD,MAAM,wBAAwB,CAAC;AA8IhN,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,aAC7C,GAAG,qBAAqB,kBACpB,aAAa,mBAKlC"}
+{"version":3,"file":"MixinTransformer.d.ts","sourceRoot":"","sources":["MixinTransformer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAiVjC,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,aAC7C,GAAG,qBAAqB,kBAEpB,GAAG,UAAU,aAQlC"}