@bikky/compiler 0.0.1

package/Source/ASTHelper.ts

@@ -0,0 +1,373 @@
+
+import * as ts from "typescript";
+
+export function Identifier(context: ts.TransformationContext, name: string) {
+	return context.factory.createIdentifier(name);
+}
+
+export function StringLiteral(context: ts.TransformationContext, name: string) {
+	return context.factory.createStringLiteral(name);
+}
+
+export function StaticModifier(context: ts.TransformationContext) {
+	return context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Static)[0];
+}
+
+export interface fromable {
+	from: (param: any)=> any;
+}
+
+export class NamedExpression {
+	name: ts.Identifier;
+
+	constructor(name: ts.Identifier) {
+		this.name = name;
+	}
+
+	getName() {
+		return this.name;
+	}
+
+	rename(name: ts.Identifier) {
+		this.name = name;
+		return this;
+	}
+}
+
+export class VariableDeclaration extends NamedExpression {
+	modifiers?: ts.Modifier[] = [];
+	value?: ts.Expression;
+
+
+	setValue(value: ts.Expression) {
+		this.value = value;
+		return this;
+	}
+
+	addModifier(modifier: ts.Modifier) {
+		if (!this.modifiers) {
+			this.modifiers = [];
+		}
+		this.modifiers.push(modifier);
+		return this;
+	}
+
+	make(context: ts.TransformationContext): ts.Node {
+		return context.factory.createVariableStatement(this.modifiers,
+			context.factory.createVariableDeclarationList(
+				[context.factory.createVariableDeclaration(this.name, undefined, undefined, this.value)]));
+	}
+}
+
+export module VariableDeclaration {
+	export function from(variable: ts.VariableDeclaration): VariableDeclaration {
+		var result = new VariableDeclaration(<ts.Identifier>variable.name);
+		result.value = variable.initializer;
+		result.modifiers = variable.modifiers ? Array.from(variable.modifiers) : undefined;
+		return result;
+	}
+}
+
+export class PropertyDeclaration extends VariableDeclaration {
+
+	//Property declarations can support a few more name types than normal variables.
+	constructor(name: ts.Identifier | ts.ComputedPropertyName) {
+		super(<ts.Identifier>name);
+	}
+
+	make(context: ts.TransformationContext) {
+		return context.factory.createPropertyDeclaration([], this.modifiers, this.name, undefined, undefined, this.value);
+	}
+}
+
+export module PropertyDeclaration {
+	export function from(variable: ts.PropertyDeclaration | ts.VariableDeclaration): PropertyDeclaration {
+		var result = new PropertyDeclaration(<ts.Identifier>variable.name);
+		result.value = variable.initializer;
+		result.modifiers = variable.modifiers ? Array.from(variable.modifiers) : undefined;
+		return result;
+	}
+}
+
+export class CallExpression extends NamedExpression {
+	arguments: ts.Expression[] = [];
+	addArgument(...arg: ts.Expression[]) {
+		this.arguments.push(...arg);
+		return this;
+	}
+	make(context: ts.TransformationContext) {
+		return context.factory.createCallExpression(this.name, undefined, this.arguments);
+	}
+}
+
+//this[super].function.call(this, arguments);
+export class AccessExpression {
+	start!: ts.Expression | ts.Identifier;
+	chain!: ts.AccessExpression;
+	context: ts.TransformationContext;
+	constructor(context: ts.TransformationContext) {
+		this.context = context;
+	}
+	this() {
+		if (!this.start) {
+			this.start = this.context.factory.createThis();
+		}
+		else {
+			throw new Error("This can only be the first expression in an access chain");
+		}
+		return this;
+	}
+	access(node: ts.Expression | ts.Identifier | ts.ComputedPropertyName) {
+		if (!this.start) {
+			this.start = <ts.Identifier>node;
+		}
+		else {
+			if (!this.chain) {
+				if (this.start.kind === ts.SyntaxKind.ThisKeyword) {
+					this.chain = this.context.factory.createElementAccessExpression(this.start, <ts.Identifier>node);
+				}
+				else {
+					this.chain = this.context.factory.createPropertyAccessExpression(this.start, <ts.Identifier>node);
+				}
+			}
+			else {
+				this.chain = this.context.factory.createPropertyAccessExpression(this.chain, <ts.Identifier>node);
+			}
+		}
+		return this;
+	}
+	make() {
+		return this.chain;
+	}
+}
+
+export class ClassDeclaration extends NamedExpression {
+	original?: ts.ClassDeclaration;
+	decorators: ts.Decorator[] = [];
+	extends: ts.Expression | undefined;
+	members: (ts.ClassElement)[] = [];
+
+	static from(oldClass: ts.ClassDeclaration) {
+		var Class = new ClassDeclaration(oldClass.name!);
+		Class.original = oldClass;
+		if (oldClass.heritageClauses) {
+			for (var clause of oldClass.heritageClauses) {
+				if ((<ts.HeritageClause>clause).token == ts.SyntaxKind.ExtendsKeyword) {
+					Class.extends = clause.types[0].expression;
+				}
+			}
+		}
+		Class.members = Array.from(oldClass.members);
+		if (oldClass.decorators) {
+			Class.decorators = Array.from(oldClass.decorators);
+		}
+		return Class;
+	}
+
+	addMemberAtStart(member: ts.ClassElement) {
+		this.members.unshift(member);
+		return this;
+	}
+
+	addMember(member: ts.ClassElement) {
+		this.members.push(member);
+		return this;
+	}
+
+	hasDecorator(identifier: string | ts.Identifier) {
+		var name = (typeof identifier === "string") ? identifier : identifier.text;
+		for (var i = 0; i < this.decorators.length; i++) {
+			var decorator = this.decorators[i];
+			if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
+				return true;
+			}
+			else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	removeDecorator(identifier: string | ts.Identifier) {
+		var name = (typeof identifier === "string") ? identifier : identifier.text;
+		for (var i = 0; i < this.decorators.length; i++) {
+			var decorator = this.decorators[i];
+			if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
+				this.decorators.splice(i, 1);
+				return this;
+			}
+			else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
+				this.decorators.splice(i, 1);
+				return this;
+			}
+		}
+		return this;
+	}
+
+	hasExtends() {
+		return !!this.extends;
+	}
+
+	getExtends() {
+		return this.extends;
+	}
+
+	setExtends(Extends: ts.Expression | undefined) {
+		this.extends = Extends;
+		return this;
+	}
+
+	static eachContextualNode(Class: ts.ClassDeclaration, foo: ts.Visitor, context: ts.TransformationContext) {
+		var statement = (node: ts.Node): ts.VisitResult<ts.Node> => {
+			if (ts.isBlock(node)) {
+				return blocks(node);
+			}
+			else if (ts.isArrowFunction(node)) {
+				return members(node);
+			}
+			else {
+				var result = foo(node);
+				if (!result) {
+					return result;
+				}
+				if (Array.isArray(result)) {
+					//TODO: Should probably do something smart here?
+					return result;
+				}
+				return ts.visitEachChild(result, statement, context);
+			}
+		};
+
+		var blocks = (node: ts.Node): ts.VisitResult<ts.Node> => {
+			if (ts.isBlock(node)) {
+				return ts.visitEachChild(node, statement, context);
+			}
+			return node;
+		};
+		var members = (node: ts.Node): ts.VisitResult<ts.Node>  => {
+			if (ts.isMethodDeclaration(node)) {
+				return ts.visitEachChild(node, blocks, context);
+			}
+			else {
+				return node;
+			}
+		};
+		return ts.visitEachChild(Class, members, context);
+	}
+
+	update(context: ts.TransformationContext) {
+		if (!this.original) {
+			throw new Error("Cannot update class that doesn't exist!");
+		}
+
+		var replaceNodeArrays = (nodes: ts.NodeArray<any> | undefined, visitor: ts.Visitor | undefined, test?: (node: ts.Node) => boolean, start?: number, count?: number): ts.NodeArray<ts.Node> => {
+			if (nodes == this.original!.decorators) {
+				return context.factory.createNodeArray(this.decorators);
+			}
+			if (nodes == this.original!.members) {
+				return context.factory.createNodeArray(this.members);
+			}
+			if (nodes) {
+				var changedArray = false;
+				var newArray = [];
+				for (var node of nodes) {
+					var newNode = ts.visitNode(node, visitor, test);
+					newArray.push(newNode);
+					if (node != newNode) {
+						changedArray = true;
+					}
+				}
+				if (changedArray) {
+					return context.factory.createNodeArray(newArray);
+				}
+			}
+			return nodes!;
+		};
+
+		var replaceExports: ts.Visitor = (node: ts.Node) => {
+			if (node.kind == ts.SyntaxKind.HeritageClause && (<ts.HeritageClause>node).token == ts.SyntaxKind.ExtendsKeyword) {
+				//I hope this works...
+				var result = context.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [ts.createExpressionWithTypeArguments(undefined, this.extends!)]);
+				return result;
+			}
+			return node;
+		}
+
+		//first parameter is the class, second is the thing to edit individual nodes, third is the context
+		// last parameter is the thing to edit entire node arrays.
+		return ts.visitEachChild(this.original, replaceExports, context, replaceNodeArrays);
+	}
+}
+
+export class SourceFile {
+	original?: ts.SourceFile;
+	statements: ts.Statement[] = [];
+
+	static from(oldfile: ts.SourceFile) {
+		var file = new SourceFile;
+		file.statements = Array.from(oldfile.statements);
+		file.original = oldfile;
+		return file;
+	}
+
+	replaceNode(oldNode: ts.Statement, newNode: ts.Statement) {
+		var index = this.statements.indexOf(oldNode);
+		if (index < 0) {
+			throw new Error("Tried to replace a node that doesn't exist in file");
+		}
+		this.statements[index] = newNode;
+		return this;
+	}
+
+	insertUnderImports(node: ts.Statement) {
+		for (var i = 0; i < this.statements.length; i++) {
+			if (this.statements[i].kind !== ts.SyntaxKind.ImportDeclaration) {
+				this.statements.splice(i, 0, node);
+				break;
+			}
+		}
+		return this;
+	}
+
+	update(context: ts.TransformationContext) {
+		if (!this.original) {
+			throw new Error("Cannot update file that doesn't exist!");
+		}
+		var newSource = ts.getMutableClone(this.original);
+		//Cast to any because mutable clones use the same immutable typing as their original node.
+		(<any>newSource).statements = context.factory.createNodeArray(this.statements);
+		return newSource;
+	}
+}
+
+
+export function logError(node: ts.Node, error: string): undefined {
+	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;
+}
+
+export module Printer {
+	var printer = ts.createPrinter();
+
+	export function printNode(node: ts.Node, sourceFile: ts.SourceFile) {
+		return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+	}
+
+	export function printNodeFirstLine(node: ts.Node, sourceFile: ts.SourceFile) {
+		var code = printNode(node, node.getSourceFile());
+		//space matches tab.
+		code = code.replace(/^ *{? *\r\n?/, "");
+		return code.replace(/\r\n.*/gi, "");
+
+	}
+}

package/Source/TSPatchTypes.d.ts

@@ -0,0 +1,17 @@
+import * as ts from "typescript";
+import { ProgramTransformerExtras, PluginConfig } from 'ts-patch';
+
+
+type ProgramPatchableTS = typeof ts & {
+    createProgram(rootNames: string[], compilerOptions: PluginConfig, host: ts.CompilerHost | undefined, oldProgram: ts.Program): ts.Program;
+}
+
+
+
+type ProgramTransformer = (program: ts.Program, host: ts.CompilerHost | undefined, options: PluginConfig, pte: ProgramTransformerExtras) => ts.Program;
+
+
+type SourceTransformer = (program: ts.Program, pluginOptions: {}) => 
+    (context: ts.TransformationContext) => 
+        (sourceFile: ts.SourceFile) => ts.SourceFile;
+

package/Transformers/CompilerInsertions.ts

@@ -0,0 +1,21 @@
+/**
+ * Adds BikkyCompiler type files and supporting code into the program at compile-time.
+ */
+
+import * as ts from 'typescript';
+import * as path from 'path';
+import { ProgramTransformerExtras, PluginConfig } from 'ts-patch';
+import {ProgramPatchableTS} from "../Source/TSPatchTypes.js";
+
+export const newFile = path.resolve(__dirname, '../Libraries/GlobalTypes.d.ts');
+
+
+export default function (program: ts.Program, host: ts.CompilerHost | undefined, options: PluginConfig, pte: ProgramTransformerExtras) {
+    const tsInstance : ProgramPatchableTS = pte.ts;
+    return tsInstance.createProgram(
+        /* rootNames */ [newFile, ...program.getRootFileNames()],
+        program.getCompilerOptions(),
+        host,
+        /* oldProgram */ program
+    );
+}

package/Transformers/MacroTransformer.js

@@ -0,0 +1,273 @@
+"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;
+    }
+}
+//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) => {
+            return transformer.CrawlExpressionTree(sourceFile);
+        };
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=Macros.js.map