@flamework-experimental/transformer 2.0.0-alpha.0

package/out/transformations/statements/transformClassDeclaration.js

@@ -0,0 +1,282 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassDeclaration = transformClassDeclaration;
+var typescript_1 = __importDefault(require("typescript"));
+var nodeMetadata_1 = require("../../classes/nodeMetadata");
+var factory_1 = require("../../util/factory");
+var buildGuardFromType_1 = require("../../util/functions/buildGuardFromType");
+var uid_1 = require("../../util/uid");
+var transformUserMacro_1 = require("../transformUserMacro");
+var validateConstraintMetadata_1 = require("../../util/functions/validateConstraintMetadata");
+var diagnostics_1 = require("../../classes/diagnostics");
+var packages_1 = require("../../util/packages");
+function transformClassDeclaration(state, node) {
+    var e_1, _a;
+    var _b;
+    var symbol = state.getSymbol(node);
+    if (!symbol || !node.name)
+        return state.transform(node);
+    var metadata = nodeMetadata_1.NodeMetadata.fromCache(state, node);
+    if (!hasReflectMetadata(state, node, metadata)) {
+        return state.transform(node);
+    }
+    var importIdentifier = state.addFileImport(state.getSourceFile(node), packages_1.CORE_PACKAGE, "Reflect");
+    var reflectStatements = new Array();
+    reflectStatements.push.apply(reflectStatements, __spreadArray([], __read(convertReflectionToStatements(generateClassMetadata(state, metadata, node))), false));
+    (0, validateConstraintMetadata_1.validateConstraintMetadata)(state, node, metadata);
+    try {
+        for (var _c = __values(node.members), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var member = _d.value;
+            if (!member.name) {
+                continue;
+            }
+            var propertyName = typescript_1.default.getPropertyNameForPropertyNameNode(member.name);
+            if (!propertyName) {
+                continue;
+            }
+            var reflection = (_b = getNodeReflection(state, member)) !== null && _b !== void 0 ? _b : [];
+            if (reflection.length > 0 && typescript_1.default.hasStaticModifier(member)) {
+                diagnostics_1.Diagnostics.error(member.name, "Flamework does not support reflection on static members.");
+            }
+            reflectStatements.push.apply(reflectStatements, __spreadArray([], __read(convertReflectionToStatements(reflection, propertyName)), false));
+            (0, validateConstraintMetadata_1.validateConstraintMetadata)(state, member);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [updateClass(state, node, reflectStatements)];
+    function convertReflectionToStatements(metadata, property) {
+        var statements = metadata.map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], value = _b[1];
+            var args = [node.name, name, value];
+            if (property !== undefined) {
+                args.push(property);
+            }
+            return factory_1.f.statement(factory_1.f.call(factory_1.f.field(importIdentifier, "defineMetadata"), args));
+        });
+        addSectionComment(statements[0], node, property, "metadata");
+        return statements;
+    }
+}
+function generateFieldMetadata(state, metadata, field) {
+    var _a, _b;
+    var fields = new Array();
+    var type = state.typeChecker.getTypeAtLocation(field);
+    if (metadata.isRequested("flamework:type")) {
+        var id = (0, uid_1.getTypeUid)(state, type, (_a = field.name) !== null && _a !== void 0 ? _a : field);
+        fields.push(["flamework:type", id]);
+    }
+    if (metadata.isRequested("flamework:guard")) {
+        var guard = (0, buildGuardFromType_1.buildGuardFromType)(state, (_b = field.type) !== null && _b !== void 0 ? _b : field, type);
+        fields.push(["flamework:guard", guard]);
+    }
+    return fields;
+}
+function generateMethodMetadata(state, metadata, method) {
+    var _a, _b;
+    var fields = new Array();
+    var parameters = method.parameters.map(function (declaration) { return ({
+        declaration: declaration,
+        type: state.typeChecker.getTypeAtLocation(declaration),
+        trace: declaration,
+    }); });
+    fields.push.apply(fields, __spreadArray([], __read(generateParametersMetadata(state, metadata, parameters)), false));
+    var baseSignature = state.typeChecker.getSignatureFromDeclaration(method);
+    if (baseSignature) {
+        if (metadata.isRequested("flamework:return_type")) {
+            var id = (0, uid_1.getTypeUid)(state, baseSignature.getReturnType(), (_a = method.name) !== null && _a !== void 0 ? _a : method);
+            fields.push(["flamework:return_type", id]);
+        }
+        if (metadata.isRequested("flamework:return_guard")) {
+            var guard = (0, buildGuardFromType_1.buildGuardFromType)(state, (_b = method.type) !== null && _b !== void 0 ? _b : method, baseSignature.getReturnType());
+            fields.push(["flamework:return_guard", guard]);
+        }
+    }
+    return fields;
+}
+function generateParametersMetadata(state, metadata, parameters) {
+    var fields = new Array();
+    generateMetadata("flamework:parameters", function (param) {
+        return (0, uid_1.getTypeUid)(state, param.type, param.trace);
+    });
+    generateMetadata("flamework:parameter_names", function (param) {
+        return param.declaration && factory_1.f.is.identifier(param.declaration.name) ? param.declaration.name.text : "_binding_";
+    });
+    generateMetadata("flamework:parameter_guards", function (param) {
+        var _a;
+        return (0, buildGuardFromType_1.buildGuardFromType)(state, (_a = param.declaration) !== null && _a !== void 0 ? _a : param.trace, param.type);
+    });
+    generateMetadata("flamework:dependencies", function (param) {
+        return (0, transformUserMacro_1.getDependencyInjectionMetadata)(state, param.trace, param.type);
+    });
+    return fields;
+    function generateMetadata(name, callback) {
+        var e_2, _a;
+        if (metadata.isRequested(name)) {
+            var values = new Array();
+            try {
+                for (var parameters_1 = __values(parameters), parameters_1_1 = parameters_1.next(); !parameters_1_1.done; parameters_1_1 = parameters_1.next()) {
+                    var parameter = parameters_1_1.value;
+                    values.push(callback(parameter));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (parameters_1_1 && !parameters_1_1.done && (_a = parameters_1.return)) _a.call(parameters_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            fields.push([name, values]);
+        }
+    }
+}
+function generateClassMetadata(state, metadata, node) {
+    var e_3, _a, e_4, _b;
+    var symbol = state.getSymbol(node);
+    var fields = [];
+    if (metadata.isRequested("identifier")) {
+        fields.push(["identifier", (0, uid_1.getNodeTypeUid)(state, node)]);
+    }
+    if (metadata.isRequested("flamework:implements")) {
+        var implementClauses = new Array();
+        if (node.heritageClauses) {
+            try {
+                for (var _c = __values(node.heritageClauses), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var clause = _d.value;
+                    if (clause.token !== typescript_1.default.SyntaxKind.ImplementsKeyword) {
+                        continue;
+                    }
+                    try {
+                        for (var _e = (e_4 = void 0, __values(clause.types)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var type = _f.value;
+                            implementClauses.push(factory_1.f.string((0, uid_1.getNodeTypeUid)(state, type)));
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        fields.push(["flamework:implements", factory_1.f.array(implementClauses, false)]);
+    }
+    var _g = __read(state.typeChecker.getTypeOfSymbol(symbol).getConstructSignatures(), 1), firstSignature = _g[0];
+    if (firstSignature !== undefined) {
+        // The parameter *types* come from the signature, not the declarations, so that a constructor
+        // inherited from a generic base is seen with its type arguments applied.
+        var parameters = firstSignature.parameters.map(function (parameter, index) {
+            var _a, _b;
+            var declaration = (_a = parameter.declarations) === null || _a === void 0 ? void 0 : _a.find(typescript_1.default.isParameter);
+            return {
+                declaration: declaration,
+                type: state.typeChecker.getParameterType(firstSignature, index),
+                trace: (_b = declaration !== null && declaration !== void 0 ? declaration : node.name) !== null && _b !== void 0 ? _b : node,
+            };
+        });
+        fields.push.apply(fields, __spreadArray([], __read(generateParametersMetadata(state, metadata, parameters)), false));
+    }
+    return fields;
+}
+function getNodeReflection(state, node, metadata) {
+    if (metadata === void 0) { metadata = nodeMetadata_1.NodeMetadata.fromCache(state, node); }
+    if (factory_1.f.is.methodDeclaration(node)) {
+        return generateMethodMetadata(state, metadata, node);
+    }
+    else if (factory_1.f.is.propertyDeclaration(node)) {
+        return generateFieldMetadata(state, metadata, node);
+    }
+}
+function addSectionComment(node, declaration, property, label) {
+    if (!node) {
+        return;
+    }
+    var elementName = property === undefined ? "".concat(declaration.name.text) : "".concat(declaration.name.text, ".").concat(property);
+    typescript_1.default.addSyntheticLeadingComment(node, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, " (Flamework) ".concat(elementName, " ").concat(label));
+}
+function updateClass(state, node, staticStatements) {
+    var _a;
+    var members = node.members.map(function (node) { return state.transformNode(node); });
+    if (staticStatements) {
+        members.push(factory_1.f.staticBlockDeclaration(staticStatements));
+    }
+    return factory_1.f.update.classDeclaration(node, node.name ? state.transformNode(node.name) : undefined, members, node.heritageClauses, node.typeParameters, (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.map(function (v) { return state.transformNode(v); }));
+}
+function hasReflectMetadata(state, declaration, metadata) {
+    var e_5, _a;
+    if (metadata.isRequested("reflect")) {
+        return true;
+    }
+    try {
+        for (var _b = __values(declaration.members), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var member = _c.value;
+            var metadata_1 = nodeMetadata_1.NodeMetadata.fromCache(state, member);
+            if (metadata_1.isRequested("reflect")) {
+                return true;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return false;
+}

package/out/transformations/transformExpression.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformExpression = transformExpression;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnosticsUtils_1 = require("../util/diagnosticsUtils");
+var transformAccessExpression_1 = require("./expressions/transformAccessExpression");
+var transformBinaryExpression_1 = require("./expressions/transformBinaryExpression");
+var transformCallExpression_1 = require("./expressions/transformCallExpression");
+var transformDeleteExpression_1 = require("./expressions/transformDeleteExpression");
+var transformNewExpression_1 = require("./expressions/transformNewExpression");
+var transformUnaryExpression_1 = require("./expressions/transformUnaryExpression");
+var transformNode_1 = require("./transformNode");
+var TRANSFORMERS = new Map([
+    [typescript_1.default.SyntaxKind.CallExpression, transformCallExpression_1.transformCallExpression],
+    [typescript_1.default.SyntaxKind.NewExpression, transformNewExpression_1.transformNewExpression],
+    [typescript_1.default.SyntaxKind.ElementAccessExpression, transformAccessExpression_1.transformAccessExpression],
+    [typescript_1.default.SyntaxKind.PropertyAccessExpression, transformAccessExpression_1.transformAccessExpression],
+    [typescript_1.default.SyntaxKind.BinaryExpression, transformBinaryExpression_1.transformBinaryExpression],
+    [typescript_1.default.SyntaxKind.PrefixUnaryExpression, transformUnaryExpression_1.transformUnaryExpression],
+    [typescript_1.default.SyntaxKind.PostfixUnaryExpression, transformUnaryExpression_1.transformUnaryExpression],
+    [typescript_1.default.SyntaxKind.DeleteExpression, transformDeleteExpression_1.transformDeleteExpression],
+]);
+function transformExpression(state, expression) {
+    return (0, diagnosticsUtils_1.catchDiagnostic)(expression, function () {
+        var transformer = TRANSFORMERS.get(expression.kind);
+        if (transformer) {
+            return transformer(state, expression);
+        }
+        return typescript_1.default.visitEachChild(expression, function (newNode) { return (0, transformNode_1.transformNode)(state, newNode); }, state.context);
+    });
+}

package/out/transformations/transformFile.js

@@ -0,0 +1,78 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFile = transformFile;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../classes/diagnostics");
+var factory_1 = require("../util/factory");
+var transformStatementList_1 = require("./transformStatementList");
+function transformFile(state, file) {
+    var e_1, _a;
+    state.buildInfo.invalidateGlobs(state.getFileId(file));
+    var statements = (0, transformStatementList_1.transformStatementList)(state, file.statements);
+    var imports = state.fileImports.get(file.fileName);
+    if (imports) {
+        var firstStatement = statements[0];
+        statements.unshift.apply(statements, __spreadArray([], __read(imports.map(function (info) {
+            return factory_1.f.importDeclaration(info.path, info.entries.map(function (x) { return [x.name, x.identifier]; }));
+        })), false));
+        // steal comments from original first statement so that comment directives work properly
+        if (firstStatement && statements[0]) {
+            typescript_1.default.copyComments(firstStatement, statements[0]);
+            typescript_1.default.removeAllComments(firstStatement);
+        }
+    }
+    try {
+        for (var _b = __values(diagnostics_1.Diagnostics.flush()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var diag = _c.value;
+            state.addDiagnostic(diag);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var sourceFile = factory_1.f.update.sourceFile(file, statements);
+    return sourceFile;
+}