@bikky/compiler 0.1.17 → 0.2.0

package/Transformers/ReplicableTransformer.js

@@ -1,786 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Crawler_js_1 = require("../Source/ASTInterface/Crawler.js");
-const ts = require("../Cache/typescript");
-const typescript_1 = require("../Cache/typescript");
-const ASTHelper_js_1 = require("../Source/ASTHelper.js");
-const ts_clone_node_1 = require("ts-clone-node");
-const MiscHelpers_js_1 = require("../Source/MiscHelpers.js");
-var printNode = ASTHelper_js_1.Printer.printNode;
-//TODO:
-// CustomLoad should change DataName.?
-// Support for object types?
-/**
- * This transformer takes the @InlineClass, @AddressableClass and @Property decorators and constructs two files
- * from this information; the first file is a definition file that contains the valid initialisation, replication
- * and constructor data types for the class. The second file contains data that will be ingested by the
- * replication library to do the necessary data transformations during load, serialisation and construction.
- *
- * Benefits of doing this during compile are both that some calculations can be cached (see below) and also that
- * you can visually inspect the generated file for correctness.
- * Ideally we can additionally check at compile time that types are correct, e.g. that types referenced within a
- * @Property are actually classes that have been declared with @InlineClass or @AddressableClass, and that all
- * @AddressableClasses are referenced using Pointers.
- *
- * We can cheat a bit here and apply the correct loading functions for child data if we already know exactly what
- * types it can possibly be. Meaning that we can avoid the runtime having to both check what types are valid and
- * then checking if the data matches those types. Finally, when the serialisation and deserialisation code changes
- * to use binary instead of JSON, the functions can be easily used to directly read and write binary data.
- *
- * Type checking functions should be chainable so we can have:
- * [Array, Array, InlineClass] be checked as "is this an array?" -> "is each entry an array?"
- * -> "is each entry of the second array an InlineClass?".
- * We also need to support arbitrarily composable unions of types, so we can have something like
- * (InlineClassA | InlineClassB)[] or InlineClassA | (InlineClassB[]).
- *
- * @Properties that reference @InlineClasses will make the containing class dependant on the inline class,
- * meaning if the inline class is hot reloaded the containing class will also be reloaded.
- */
-//RBF = Replication Breakdown File.
-const rbfExt = ".rbf.js";
-const defExt = ".data.d.ts";
-const Klasses = new Map;
-let currentFile = null;
-let allFileImports = new Map();
-let currentFileAliases = new Map();
-let rbfImports = new Map();
-let defImports = new Map();
-let rbfContents = [];
-let defContents = new Map;
-function resolveAliases(name) {
-    while (currentFileAliases.has(name)) {
-        name = currentFileAliases.get(name);
-    }
-    return name;
-}
-function makeDataName(name) {
-    return name[0].toUpperCase() + name.slice(1);
-}
-function printRBFClass(klass) {
-    return (`
-	Name: "${klass.Name}",
-	DataName: "${klass.DataName}",
-	Referenced: ${klass.Referenced},
-	Parents: [${klass.Parents.map(p => `${resolveAliases(p) + "RBF"}`).join(", ")}],
-	AllPropertyNames: [],
-	OwnPropertyNames: [${klass.OwnPropertyNames.sort().map((e) => `"${e}"`).join(", ")}],
-	Properties: {` +
-        Object.getOwnPropertyNames(klass.Properties).map((e) => {
-            let propNames = Object.getOwnPropertyNames(klass.Properties[e]);
-            let output = [];
-            for (let propName of propNames) {
-                let propData = klass.Properties[e][propName];
-                output.push(`\n\t\t\t["${propName}"]: {`
-                    + `\n\t\t\t\tDataName: "` + propData.DataName + `",`
-                    + `\n\t\t\t\tConfig: ` +
-                    JSON.stringify(propData.Config, null, 4)
-                        .replace(/\n/g, "\n\t\t\t\t")
-                        .replace(/ {4}/g, "\t") + ","
-                    + `\n\t\t\t\tTypescript: ` + JSON.stringify(propData.Typescript) + ","
-                    + `\n\t\t\t\tSerialised: ` + JSON.stringify(propData.Serialised) + ","
-                    + `\n\t\t\t\tData: ` + JSON.stringify(propData.Data)
-                    + `\n\t\t\t}`);
-            }
-            return `\n\t\t[${e}]: {` + output.join(",") + `\n\t\t}`;
-        }).join(",\n")
-        + `\n\t}`).trim() + "\n";
-}
-const warning = `
-// This file is automatically generated by the bikky compiler.
-`.trim();
-Crawler_js_1.Crawler.OnFile((node) => {
-    allFileImports.clear();
-    currentFileAliases.clear();
-    rbfImports.clear();
-    rbfContents = [];
-    currentFile = node.ts;
-    defContents.clear();
-});
-Crawler_js_1.Crawler.OnFileCompleted((node => {
-    //Only emit if we have something TO emit.
-    if (currentFile && rbfContents.length > 0) {
-        let imports = Array.from(rbfImports.entries()).map(([key, value]) => {
-            value = Array.from(new Set(value));
-            return `import { ${value.join(", ")} } from "${key}";`;
-        });
-        imports.push(`import { Replicable } from "@bikky/replication";`);
-        Crawler_js_1.Crawler.writeSupplementaryFile(currentFile.fileName.slice(0, -3) + rbfExt, imports.join("\n") + "\n\n" + warning + "\n\n" +
-            rbfContents.map((e, i) => `export const ${e.Name}RBF = {\n\t${printRBFClass(e)}};\n`
-                + (e.Parents.length > 0 ? `${e.Name}RBF.AllPropertyNames = ${e.Name}RBF.OwnPropertyNames.concat(${e.Parents.map((e) => `${e}RBF.AllPropertyNames`).join(", ")});\n` : "")
-                + `${e.Name}RBF.AllPropertyNames = Array.from(new Set(${e.Name}RBF.AllPropertyNames)).sort();\n`
-                + `Replicable.registerClass(${e.Name}RBF);`).join("\n\n\n"));
-        imports = Array.from(defImports.entries()).map(([key, value]) => {
-            value = Array.from(new Set(value));
-            return `import { ${value.join(", ")} } from "${key}";`;
-        });
-        Crawler_js_1.Crawler.writeSupplementaryFile(currentFile.fileName.slice(0, -3) + defExt, imports.join("\n") + "\n\n" + warning + "\n\n" +
-            rbfContents.map((e) => {
-                var _a, _b, _c, _d, _e, _f;
-                let propInfos = defContents.get(e.Name);
-                if (e.Parents.length > 0) {
-                    return `export interface ${e.Name}Data extends ${e.Parents.map((e) => `Omit<${e + "Data"}, "Class">`).join(", ")} {\n` +
-                        `\tClass: "${e.Name}";\n` +
-                        ((_a = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.dataName}": ${p.data};`).join("\n")) !== null && _a !== void 0 ? _a : "") +
-                        `\n}\n\n` +
-                        `export interface ${e.Name}Serialised extends ${e.Parents.map((e) => e + "Serialised").join(", ")} {\n` +
-                        `\tversion: string;\n` +
-                        ((_b = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.propName}": ${p.serialised};`).join("\n")) !== null && _b !== void 0 ? _b : "") +
-                        `\n}\n\n` +
-                        `export interface ${e.Name}Construct extends ${e.Parents.map((e) => `Omit<${e + "Construct"}, "Class">`).join(", ")} {\n` +
-                        `\tClass: "${e.Name}";\n` +
-                        ((_c = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.dataName}"?: ${p.construct};`).join("\n")) !== null && _c !== void 0 ? _c : "") +
-                        `\n}\n\n` +
-                        `export type ${e.Name}SerialisedReference = [ string, ${e.Name}Serialised ];\n\n`;
-                }
-                else {
-                    return `export interface ${e.Name}Data {\n` +
-                        `\tClass: "${e.Name}";\n` +
-                        ((_d = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.dataName}": ${p.data};`).join("\n")) !== null && _d !== void 0 ? _d : "") +
-                        `\n}\n\n` +
-                        `export interface ${e.Name}Serialised {\n` +
-                        `\tversion: string;\n` +
-                        ((_e = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.propName}": ${p.serialised};`).join("\n")) !== null && _e !== void 0 ? _e : "") +
-                        `\n}\n\n` +
-                        `export interface ${e.Name}Construct {\n` +
-                        `\tClass: "${e.Name}";\n` +
-                        ((_f = propInfos === null || propInfos === void 0 ? void 0 : propInfos.map((p) => `\t"${p.dataName}"?: ${p.construct};`).join("\n")) !== null && _f !== void 0 ? _f : "") +
-                        `\n}\n\n` +
-                        `export type ${e.Name}SerialisedReference = [ string, ${e.Name}Serialised ];\n\n`;
-                }
-            }).join("\n"));
-    }
-    return node.ts;
-}));
-Crawler_js_1.Crawler.Register((node) => {
-    if (ts.isImportDeclaration(node) && node.importClause) {
-        return true;
-    }
-    return false;
-}, (node) => {
-    let declaration = node;
-    let localPath = declaration.moduleSpecifier.getText().slice(1, -1);
-    // let rbfpath = joinPaths(getPathDir(node.getSourceFile().fileName), localPath)
-    // 	.replace(/\.ts$/, rbfExt);
-    let rbfpath = localPath.replace(/\.js$/, rbfExt);
-    // let defpath = localPath.replace(/\.js$/, defExt);
-    let clause = declaration.importClause;
-    if (clause.name) {
-        // import name from "module"
-        allFileImports.set(clause.name.getText() + "RBF", rbfpath);
-        allFileImports.set(clause.name.getText(), localPath);
-    }
-    else if (clause.namedBindings) {
-        if ("elements" in clause.namedBindings) {
-            for (let binding of clause.namedBindings.elements) {
-                // import { name as alias } from "module"
-                // import { name } from "module"
-                if (ts.isImportSpecifier(binding)) {
-                    if (binding.propertyName) {
-                        currentFileAliases.set(binding.propertyName.getText(), binding.name.getText());
-                    }
-                    allFileImports.set(binding.name.getText() + "RBF", rbfpath);
-                    allFileImports.set(binding.name.getText(), localPath);
-                }
-            }
-        }
-        else {
-            // import * as name from "module"
-            allFileImports.set(clause.namedBindings.name.getText() + "RBF", rbfpath);
-            allFileImports.set(clause.namedBindings.name.getText(), localPath);
-        }
-    }
-    return node;
-});
-//Remember all classes that are marked as InlineClass or AddressableClass.
-Crawler_js_1.Crawler.Register((node) => {
-    if (ts.isDecorator(node) && (ts.isClassDeclaration(node.parent) || ts.isClassExpression(node.parent))) {
-        let decorator = node;
-        let decoratorName = ts.isCallExpression(decorator.expression) ? decorator.expression.expression.getText() : decorator.expression.getText();
-        if (decoratorName === "InlineClass" || decoratorName === "AddressableClass") {
-            if (ts.isClassDeclaration(node.parent)) {
-                return true;
-            }
-            else if (ts.isClassExpression(node.parent) && "name" in node.parent && node.parent.name) {
-                return true;
-            }
-            else {
-                (0, ASTHelper_js_1.logError)(node, `Decorator @${decoratorName} can only be applied to named classes.`);
-                return false;
-            }
-        }
-        return false;
-    }
-    return false;
-}, (node) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    let decorator = node;
-    let decoratorName = ts.isCallExpression(decorator.expression) ? decorator.expression.expression.getText() : decorator.expression.getText();
-    let klassNode = node.parent;
-    if (decoratorName === "InlineClass" || decoratorName === "AddressableClass") {
-        let klassName = klassNode.name.text;
-        let klassExtends = (_b = (_a = klassNode.heritageClauses) === null || _a === void 0 ? void 0 : _a.find(hc => hc.token === ts.SyntaxKind.ExtendsKeyword)) !== null && _b !== void 0 ? _b : null;
-        let klassParents = [];
-        if (klassExtends) {
-            try {
-                klassParents = (0, MiscHelpers_js_1.getAllInheritedMixinClassNames)(klassExtends);
-                //Import the RBF file for each parent - if we can find an import statement for that parent - otherwise
-                // we assume the class is declared in the same file that it's extended from.
-                for (let parent of klassParents) {
-                    if (allFileImports.has(parent)) {
-                        let rbfPath = allFileImports.get(parent).slice(0, -3) + rbfExt;
-                        let rbfImporter = (_c = rbfImports.get(rbfPath)) !== null && _c !== void 0 ? _c : [];
-                        rbfImports.set(rbfPath, rbfImporter);
-                        rbfImporter.push(parent + "RBF");
-                    }
-                }
-            }
-            catch (e) {
-                console.error(e.message);
-            }
-        }
-        for (let value of klassParents) {
-            let impo = allFileImports.get(resolveAliases(value));
-            if (impo) {
-                //Add parents to imports for rbf file.
-                let arr = (_d = rbfImports.get(impo.slice(0, -3) + rbfExt)) !== null && _d !== void 0 ? _d : [];
-                rbfImports.set(impo.slice(0, -3) + rbfExt, arr);
-                arr.push(resolveAliases(value) + "RBF");
-                //Add parents to imports for def file.
-                arr = (_e = defImports.get(impo.slice(0, -3) + defExt)) !== null && _e !== void 0 ? _e : [];
-                defImports.set(impo.slice(0, -3) + defExt, arr);
-                arr.push(resolveAliases(value) + "Data");
-                arr.push(resolveAliases(value) + "Serialised");
-                arr.push(resolveAliases(value) + "Construct");
-            }
-        }
-        let klassGenerics = (_g = (_f = klassNode.typeParameters) === null || _f === void 0 ? void 0 : _f.map(e => e.name.getText())) !== null && _g !== void 0 ? _g : [];
-        let klassInfo = {
-            Name: klassName,
-            DataName: klassName,
-            Referenced: decoratorName === "AddressableClass",
-            Parents: klassParents,
-            Generics: klassGenerics,
-            AllPropertyNames: [],
-            OwnPropertyNames: [],
-            Properties: {},
-            ExposedFunctions: []
-        };
-        Klasses.set(klassName, klassInfo);
-        rbfContents.push(klassInfo);
-    }
-    //Don't remove the node - Replicable can use it to determine if there's an RBF to be imported.
-    return node;
-});
-var MakeRBFTypes;
-(function (MakeRBFTypes) {
-    MakeRBFTypes.primitiveReaders = {
-        Array: {
-            shouldGroup: false,
-            serialisedName: "Array",
-            isThisType: (node) => {
-                if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === "Array") {
-                    return {
-                        valid: true,
-                        containsTypes: [...node.typeArguments]
-                    };
-                }
-                if (!ts.isArrayTypeNode(node))
-                    return false;
-                return {
-                    valid: true,
-                    containsTypes: [node.elementType],
-                };
-            },
-        },
-        Dict: {
-            shouldGroup: false,
-            serialisedName: "Dict",
-            //{[index: first]: second}
-            isThisType: (node) => {
-                if (ts.isTypeLiteralNode(node) && node.members.length === 1 && node.members[0].kind == ts.SyntaxKind.IndexSignature) {
-                    let signature = node.members[0];
-                    return {
-                        valid: true,
-                        containsTypes: [signature.parameters[0].type, signature.type]
-                    };
-                }
-                return false;
-            }
-        },
-        Map: {
-            shouldGroup: false,
-            serialisedName: "Map",
-            isThisType: (node) => {
-                if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === "Map") {
-                    return {
-                        valid: true,
-                        containsTypes: [...node.typeArguments]
-                    };
-                }
-                return false;
-            }
-        },
-        String: {
-            shouldGroup: true,
-            serialisedName: "Primitive",
-            isThisType: (node) => {
-                if (node.kind === ts.SyntaxKind.StringKeyword) {
-                    return true;
-                }
-                if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.StringLiteral) {
-                    return {
-                        valid: true,
-                        values: [node.literal.text]
-                    };
-                }
-                return false;
-            },
-            tryReadLiteral: (node) => {
-                return ts.isStringLiteral(node) ? node.text : null;
-            }
-        },
-        Boolean: {
-            shouldGroup: true,
-            serialisedName: "Primitive",
-            isThisType: (node) => {
-                if (node.kind == ts.SyntaxKind.BooleanKeyword) {
-                    return true;
-                }
-                else if (ts.isLiteralTypeNode(node)) {
-                    if (node.literal.kind === ts.SyntaxKind.TrueKeyword) {
-                        return {
-                            valid: true,
-                            values: [true]
-                        };
-                    }
-                    else if (node.literal.kind === ts.SyntaxKind.FalseKeyword) {
-                        return {
-                            valid: true,
-                            values: [false]
-                        };
-                    }
-                }
-                return false;
-            },
-            tryReadLiteral(node) {
-                return node.kind === ts.SyntaxKind.TrueKeyword ? true : node.kind === ts.SyntaxKind.FalseKeyword ? false : null;
-            }
-        },
-        Number: {
-            shouldGroup: true,
-            serialisedName: "Primitive",
-            isThisType: (node) => {
-                if (node.kind === ts.SyntaxKind.NumberKeyword) {
-                    return true;
-                }
-                if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.NumericLiteral) {
-                    return {
-                        valid: true,
-                        values: [node.literal.text.includes(".") ?
-                                parseInt(node.literal.text) : parseFloat(node.literal.text),]
-                    };
-                }
-                return false;
-            },
-            tryReadLiteral(node) {
-                return ts.isNumericLiteral(node) ? (node.text.includes(".") ?
-                    parseInt(node.text) : parseFloat(node.text)) : null;
-            }
-        },
-        Object: {
-            shouldGroup: false,
-            serialisedName: "Object",
-            isThisType: (node) => {
-                return ts.isTypeLiteralNode(node) || node.kind === ts.SyntaxKind.AnyKeyword;
-            }
-        }
-    };
-    function recurseBasicType(child, childrenTypes) {
-        for (let readerName of Object.getOwnPropertyNames(MakeRBFTypes.primitiveReaders)) {
-            let reader = MakeRBFTypes.primitiveReaders[readerName];
-            let result = reader.isThisType(child);
-            if (result === false)
-                continue;
-            if (result === true) {
-                //Empty!
-                childrenTypes[readerName] = {};
-                return;
-            }
-            if (!result.valid)
-                continue;
-            if (!childrenTypes[readerName]) {
-                childrenTypes[readerName] = {};
-            }
-            if (result.values) {
-                if (!childrenTypes[readerName].values) {
-                    childrenTypes[readerName].values = [];
-                }
-                childrenTypes[readerName].values.push(...result.values);
-            }
-            if (result.containsTypes) {
-                if (!childrenTypes[readerName].subTypes) {
-                    childrenTypes[readerName].subTypes = [];
-                }
-                childrenTypes[readerName].subTypes.push(...result.containsTypes.map((e) => recursivelyConvertType(e)));
-            }
-            return;
-        }
-        if (ts.isTypeReferenceNode(child) && ts.isIdentifier(child.typeName)) {
-            childrenTypes[child.typeName.text] = {};
-            return;
-        }
-        (0, ASTHelper_js_1.logError)(child, `Unsupported type value for @Property, @Get or @Function syntax :${ts.SyntaxKind[child.kind]}`);
-        childrenTypes["Unknown"] = {};
-    }
-    MakeRBFTypes.recurseBasicType = recurseBasicType;
-    function recursivelyConvertType(typeNode) {
-        if (ts.isUnionTypeNode(typeNode)) {
-            let childrenTypes = {};
-            loopUnionContents: for (let child of typeNode.types) {
-                recurseBasicType(child, childrenTypes);
-            }
-            let names = Object.getOwnPropertyNames(childrenTypes);
-            if (names.length === 1) {
-                let name = names[0];
-                let type = childrenTypes[name];
-                return {
-                    Is: name,
-                    RestrictedTo: type.values,
-                    Containing: type.subTypes,
-                };
-                ;
-            }
-            return {
-                OR: Object.getOwnPropertyNames(childrenTypes).map((name) => {
-                    return {
-                        Is: name,
-                        RestrictedTo: childrenTypes[name].values,
-                        Containing: childrenTypes[name].subTypes,
-                    };
-                })
-            };
-        }
-        let childrenTypes = {};
-        recurseBasicType(typeNode, childrenTypes);
-        let name = Object.getOwnPropertyNames(childrenTypes)[0];
-        let type = childrenTypes[name];
-        return {
-            Is: name,
-            RestrictedTo: type.values,
-            Containing: type.subTypes,
-        };
-    }
-    MakeRBFTypes.recursivelyConvertType = recursivelyConvertType;
-    function extractConfigData(arg) {
-        let result = {};
-        //iterate each property.
-        for (let pa of arg.properties) {
-            if (!ts.isPropertyAssignment(pa)) {
-                (0, ASTHelper_js_1.logError)(pa, `@Property preprocessor command only accepts literal property assignments.`);
-                continue;
-            }
-            let name = pa.name.getText();
-            switch (name) {
-                case "computed": {
-                    let value = MakeRBFTypes.primitiveReaders.Boolean.tryReadLiteral(pa.initializer);
-                    if (value === null) {
-                        value = MakeRBFTypes.primitiveReaders.String.tryReadLiteral(pa.initializer);
-                    }
-                    if (value === null || (typeof value === "string" && value !== "manualLoad")) {
-                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value can only be "manualLoad" or boolean literal.`);
-                        continue;
-                    }
-                    result[name] = value;
-                    continue;
-                }
-                case "dataName": {
-                    let value = MakeRBFTypes.primitiveReaders.String.tryReadLiteral(pa.initializer);
-                    if (value === null) {
-                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value must be a string.`);
-                        continue;
-                    }
-                    result[name] = value;
-                    continue;
-                }
-                case "customLoad":
-                case "readonly":
-                case "manualRestore":
-                case "expression":
-                case "setter":
-                case "inline":
-                case "optional":
-                case "id": {
-                    let value = MakeRBFTypes.primitiveReaders.Boolean.tryReadLiteral(pa.initializer);
-                    if (value === null) {
-                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value must be a boolean.`);
-                        continue;
-                    }
-                    result[name] = value;
-                    continue;
-                }
-                case "default": {
-                    result[name] = printNode(pa, Crawler_js_1.Crawler.GetFile().ts, typescript_1.EmitHint.Unspecified);
-                    continue;
-                }
-            }
-            (0, ASTHelper_js_1.logError)(pa, `Invalid value for @Property configuration, ${name}`);
-        }
-        return result;
-    }
-    MakeRBFTypes.extractConfigData = extractConfigData;
-})(MakeRBFTypes || (MakeRBFTypes = {}));
-const PlainTypes = [
-    ts.SyntaxKind.AnyKeyword,
-    ts.SyntaxKind.UnknownKeyword,
-    ts.SyntaxKind.StringKeyword,
-    ts.SyntaxKind.NumberKeyword,
-    ts.SyntaxKind.BigIntKeyword,
-    ts.SyntaxKind.BooleanKeyword,
-    ts.SyntaxKind.SymbolKeyword,
-    ts.SyntaxKind.VoidKeyword,
-    ts.SyntaxKind.UndefinedKeyword,
-    ts.SyntaxKind.NullKeyword,
-    ts.SyntaxKind.ThisKeyword,
-    ts.SyntaxKind.NeverKeyword,
-];
-function convertTypeToDeclarationFormats(postfixes, node) {
-    node = (0, ts_clone_node_1.cloneNode)(node, { factory: Crawler_js_1.Crawler.getContext().factory });
-    /**
-     * Update the provided type reference's identifiers to use the provided postfixes.
-     */
-    function importAndConvertIdentifiers(typeNode, typeArgs) {
-        var _a, _b;
-        let className = ts.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : typeNode.typeName.text;
-        //Handle edge-cases for built-in types. We don't map them to serialised classes we treat them as primitives.
-        if (ts.isIdentifier(typeNode.typeName) && (className === "Array" || className === "Map" || className === "Set")) {
-            let results = [ts.factory.updateTypeReferenceNode(typeNode, typeNode.typeName, typeArgs)];
-            if (postfixes.includes("SerialisedReference")) {
-                let serialised = ts.factory.createTupleTypeNode([
-                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(className)),
-                    ts.factory.updateTypeReferenceNode(typeNode, typeNode.typeName, typeArgs)
-                ]);
-                if (postfixes.length > 1) {
-                    results.push(serialised);
-                }
-                else {
-                    results[0] = serialised;
-                }
-            }
-            if (results.length === 1)
-                return results[0];
-            return ts.factory.createUnionTypeNode(results);
-        }
-        let importedNode = typeNode.typeName;
-        while (ts.isQualifiedName(importedNode)) {
-            importedNode = importedNode.left;
-        }
-        if (!ts.isIdentifier(importedNode)) {
-            (0, ASTHelper_js_1.logError)(typeNode, `Left-most value in a reference type is not an identifier, abandoning attempt to import.`);
-            importedNode = null;
-        }
-        let results = [];
-        for (let postfix of postfixes) {
-            let renamedNode = (0, ts_clone_node_1.cloneNode)(typeNode.typeName);
-            //Update the name.
-            {
-                let newNameNode = ts.factory.createIdentifier(className + postfix);
-                if (ts.isQualifiedName(renamedNode)) {
-                    ts.factory.updateQualifiedName(renamedNode, renamedNode.left, newNameNode);
-                }
-                else {
-                    renamedNode = newNameNode;
-                }
-            }
-            let finalType = ts.factory.createTypeReferenceNode(renamedNode, typeArgs ? ts.factory.createNodeArray(typeArgs.map((e) => (0, ts_clone_node_1.cloneNode)(e))) : undefined);
-            //Add necessary imports to file.
-            if (importedNode) {
-                let impo = allFileImports.get(importedNode.text);
-                if (!impo && postfix === "") {
-                    //create a local import.
-                    impo = "./" + Crawler_js_1.Crawler.GetFile().ts.fileName.replace(/.*[\/\\]([^\/\\]*)$/, "$1");
-                }
-                if (impo) {
-                    if (postfix === "") {
-                        //If no modification to the type then we're importing the original file.
-                        let arr = (_a = defImports.get(impo)) !== null && _a !== void 0 ? _a : [];
-                        defImports.set(impo, arr);
-                        arr.push(importedNode.text);
-                    }
-                    else {
-                        let defImpo = impo.slice(0, -3) + defExt;
-                        let arr = (_b = defImports.get(defImpo)) !== null && _b !== void 0 ? _b : [];
-                        defImports.set(defImpo, arr);
-                        arr.push(importedNode.text + postfix);
-                    }
-                }
-            }
-            results.push(finalType);
-        }
-        if (results.length === 1)
-            return results[0];
-        return ts.factory.createUnionTypeNode(results);
-    }
-    /**
-     * Recursively search through the typing nodes and convert any discovered identifiers to have
-     * the supplied postfixes.
-     */
-    function findIdentifiers(typeNode) {
-        var _a;
-        //TODO: Throw a hissy fit if the `this` type keyword is used - or just replace it with whatever the current
-        // class is.
-        if (ts.isUnionTypeNode(typeNode)) {
-            return ts.visitEachChild(typeNode, findIdentifiers, Crawler_js_1.Crawler.getContext());
-        }
-        //Handle {[name: string]: MyThing}
-        else if (ts.isTypeLiteralNode(typeNode) && typeNode.members.length === 1 && ts.isIndexSignatureDeclaration(typeNode.members[0])) {
-            //Change MyThing to MyThingSerialisedReference or MyThingData or whatever's good.
-            typeNode = ts.factory.updateTypeLiteralNode(typeNode, ts.factory.createNodeArray(typeNode.members.map((e) => {
-                let decl = e;
-                return ts.factory.updateIndexSignature(decl, decl.modifiers, decl.parameters, ts.visitNode(decl.type, findIdentifiers));
-            })));
-            //If this is serialised we need to make it ["Dict", {[name: string]: MyThing}] (and union it if we're
-            // trying for more than one type.
-            if (postfixes.includes("SerialisedReference")) {
-                if (postfixes.length > 1) {
-                    return ts.factory.createUnionTypeNode([ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Dict")), typeNode]),
-                        (0, ts_clone_node_1.cloneNode)(typeNode)]);
-                }
-                return ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Dict")), typeNode]);
-            }
-            // return the result!
-            return typeNode;
-        }
-        else if (ts.isTypeReferenceNode(typeNode)) {
-            let typeArgs = (_a = typeNode.typeArguments) === null || _a === void 0 ? void 0 : _a.map((e) => {
-                return (PlainTypes.includes(e.kind) || ts.isTypeLiteralNode(e)) ? e : ts.visitNode(e, findIdentifiers);
-            });
-            let result = importAndConvertIdentifiers(typeNode, typeArgs ? ts.factory.createNodeArray(typeArgs) : undefined);
-            return result;
-        }
-        else {
-            if (postfixes.includes("SerialisedReference")) {
-                if (postfixes.length > 1) {
-                    return ts.factory.createUnionTypeNode([ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Primitive")), typeNode]),
-                        (0, ts_clone_node_1.cloneNode)(typeNode)]);
-                }
-                return ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Primitive")), typeNode]);
-            }
-            return typeNode;
-        }
-    }
-    let resultType = ts.visitNode(node, findIdentifiers);
-    let resultString = printNode(resultType, Crawler_js_1.Crawler.GetFile().ts, ts.EmitHint.Unspecified);
-    return resultString.replace(/(?:\n|\t| {4})/g, "");
-}
-// Handle @Property, @Setter and @Getter decorators.
-Crawler_js_1.Crawler.Register((node) => {
-    if (ts.isDecorator(node) && ts.isPropertyDeclaration(node.parent) && ts.isCallExpression(node.expression) && node.expression.expression.getText() === "Property") {
-        return true;
-    }
-    return false;
-}, (node) => {
-    let decorator = node;
-    if (!ts.isCallExpression(decorator.expression) || decorator.expression.arguments.length < 1) {
-        (0, ASTHelper_js_1.logError)(decorator.expression, `@Property requires a version as the first argument.`);
-        return [];
-    }
-    if (!ts.isCallExpression(decorator.expression) || decorator.expression.arguments.length > 2) {
-        (0, ASTHelper_js_1.logError)(decorator.expression, `@Property only takes two arguments.`);
-        return [];
-    }
-    //Setup version - add imports to RBF file.
-    let version = decorator.expression.arguments[0].getText();
-    {
-        let current = decorator.expression.arguments[0];
-        while (ts.isPropertyAccessExpression(current)) {
-            if (!ts.isIdentifier(current.name)) {
-                (0, ASTHelper_js_1.logError)(decorator.expression, `@Property's version must be a constant value, not an expression.`);
-                return [];
-            }
-            current = current.expression;
-        }
-        if (!ts.isIdentifier(current)) {
-            (0, ASTHelper_js_1.logError)(decorator.expression, `@Property's version must be a constant value, not an expression.`);
-            return [];
-        }
-        let versionImportName = current.getText();
-        let importLocation = allFileImports.get(versionImportName);
-        if (!importLocation) {
-            (0, ASTHelper_js_1.logError)(decorator.expression.arguments[0], `Values used for @Property's version must be imported from another file (as the RBF file needs to import it too).`);
-            return [];
-        }
-        if (decorator.expression.arguments.length > 1 && !ts.isObjectLiteralExpression(decorator.expression.arguments[1])) {
-            (0, ASTHelper_js_1.logError)(decorator.expression, `@Property must have a config object as the second argument.`);
-            return [];
-        }
-        let importArr = rbfImports.get(importLocation);
-        if (!importArr) {
-            rbfImports.set(importLocation, importArr = []);
-        }
-        importArr.push(versionImportName);
-    }
-    let propertyNode = node.parent;
-    let klassNode = propertyNode.parent;
-    let klassName = klassNode.name.text;
-    let klassInfo = Klasses.get(klassName);
-    if (!klassInfo) {
-        console.error((0, ASTHelper_js_1.logError)(klassNode, `Class ${klassName} is not marked as @InlineClass or @AddressableClass but has a @Property decorator.`));
-        return [];
-    }
-    let propertyName = propertyNode.name.getText();
-    let dataName = makeDataName(propertyName);
-    let typeChecker = Crawler_js_1.Crawler.GetProgram().ts.getTypeChecker();
-    //Use static type if provided, otherwise dynamic type if initialiser is provided, otherwise unknown.
-    let valueType;
-    if (propertyNode.type) {
-        valueType = propertyNode.type;
-    }
-    else if (propertyNode.initializer) {
-        let newType = typeChecker.typeToTypeNode(typeChecker.getTypeAtLocation(propertyNode.initializer), propertyNode, 0);
-        if (!newType) {
-            (0, ASTHelper_js_1.logError)(propertyNode, `Replicated properties must have a type specified or be initialised to a replicable type.`);
-            newType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
-        }
-        valueType = newType;
-    }
-    else {
-        (0, ASTHelper_js_1.logError)(propertyNode, `Replicated properties must have a type specified or be initialised to a replicable type.`);
-        valueType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
-    }
-    let dataType = valueType;
-    let configData;
-    if (decorator.expression.arguments.length > 1) {
-        configData = MakeRBFTypes.extractConfigData(decorator.expression.arguments[1]);
-    }
-    if (ts.isCallExpression(decorator.expression) && decorator.expression.typeArguments && decorator.expression.typeArguments.length === 1) {
-        dataType = decorator.expression.typeArguments[0];
-    }
-    klassInfo.OwnPropertyNames.push(propertyName);
-    klassInfo.OwnPropertyNames.sort();
-    let klassDef = defContents.get(klassInfo.Name);
-    if (!klassDef) {
-        defContents.set(klassInfo.Name, klassDef = []);
-    }
-    if (!klassInfo.Properties[version]) {
-        klassInfo.Properties[version] = {};
-    }
-    klassInfo.Properties[version][propertyName] = {
-        Config: configData !== null && configData !== void 0 ? configData : {},
-        DataName: dataName,
-        Typescript: MakeRBFTypes.recursivelyConvertType(valueType),
-        Serialised: MakeRBFTypes.recursivelyConvertType(valueType),
-        Data: MakeRBFTypes.recursivelyConvertType(dataType)
-    };
-    klassDef.push({
-        propName: propertyName,
-        dataName: dataName,
-        construct: convertTypeToDeclarationFormats(["", "Construct", "Data"], valueType),
-        serialised: convertTypeToDeclarationFormats(["SerialisedReference"], valueType),
-        data: convertTypeToDeclarationFormats(["Data"], dataType),
-    });
-    //Remove the decorator.
-    return [];
-});
-// Handle @Function decorators.
-// Handle Migration function calls - which allow specifying custom migration logic for old properties/values.
-//# sourceMappingURL=ReplicableTransformer.js.map