@flamework-experimental/transformer 2.0.0-alpha.0

package/out/transformations/transformNetworkingCall.js

@@ -0,0 +1,566 @@
+"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.transformNetworkingCall = transformNetworkingCall;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../classes/diagnostics");
+var factory_1 = require("../util/factory");
+var buildSerializerFromType_1 = require("../util/functions/buildSerializerFromType");
+var packages_1 = require("../util/packages");
+/**
+ * With `networking.serialization` on, a call that sends over a networking handler packs its
+ * argument list right where it is made: the encoding is generated inline from the handler's types
+ * and the packed `(payload, blobs?)` goes to the handler's hidden `_fire` / `_invoke` entry point.
+ * A function receiver's callback is wrapped the same way so that its results leave packed.
+ *
+ * Nothing in the output can encode on its own; only these call sites do. Decoding stays in the
+ * handler metadata, because a remote's payload has to be unpacked before the guards and middleware
+ * see it, which is why the receiving side needs a function and the sending side does not.
+ *
+ * Call sites are found by type: the handler members carry hidden `_flamework_send` /
+ * `_flamework_fn` markers. A member declared `Networking.Raw*` has no marker and is left alone, as is
+ * a handler reached through a widened type (which then sends unpacked values that the peer rejects
+ * as malformed). A handler reached through `?.` is typed with `undefined` in it; the marker is looked
+ * for on the rest. An argument list that carries nothing (`bump(): void`) sends no payload at all.
+ */
+/** Sending methods and the hidden entry point each becomes. */
+var SENDERS = {
+    fire: "_fire",
+    except: "_except",
+    broadcast: "_broadcast",
+    invoke: "_invoke",
+    invokeWithTimeout: "_invokeWithTimeout",
+};
+function transformNetworkingCall(state, node) {
+    var _a;
+    if (((_a = state.projectConfig.networking) === null || _a === void 0 ? void 0 : _a.serialization) !== true)
+        return;
+    var typeChecker = state.typeChecker;
+    var callee = node.expression;
+    if (factory_1.f.is.propertyAccessExpression(callee)) {
+        var name_1 = callee.name.text;
+        var target_1 = typeChecker.getNonNullableType(typeChecker.getTypeAtLocation(callee.expression));
+        var optional = callee.questionDotToken !== undefined;
+        if (name_1 === "setCallback" && target_1.getProperty("_flamework_fn")) {
+            return transformReceiverCallback(state, node, callee.expression, target_1, optional);
+        }
+        if (SENDERS[name_1] !== undefined && target_1.getProperty("_flamework_send")) {
+            return transformSend(state, node, callee.expression, target_1, SENDERS[name_1], optional);
+        }
+    }
+    // `handler.event(...)` and `handler.fn(...)`: the call signature is the sender itself.
+    var target = typeChecker.getNonNullableType(typeChecker.getTypeAtLocation(callee));
+    if (target.getProperty("_flamework_send")) {
+        var method = target.getProperty("_invoke") ? "_invoke" : "_fire";
+        return transformSend(state, node, callee, target, method, node.questionDotToken !== undefined);
+    }
+}
+/**
+ * `handler.x.fire(lead..., a, b)` becomes `handler.x._fire(lead..., payload, blobs?)`, with the packing
+ * emitted ahead of the statement. The leading arguments (players, a timeout) pass through. The
+ * target is evaluated first, as the call would: one that is more than a plain read is bound to a
+ * local ahead of the arguments.
+ */
+function transformSend(state, node, target, targetType, method, optionalTarget) {
+    var typeChecker = state.typeChecker;
+    var signature = typeChecker.getResolvedSignature(node);
+    var declaration = signature === null || signature === void 0 ? void 0 : signature.declaration;
+    if (!declaration || !typescript_1.default.isFunctionLike(declaration))
+        return;
+    // The declared signature is `(lead..., ...args: I)`; the resolved one has `I` expanded.
+    var restIndex = declaration.parameters.findIndex(function (parameter) { return parameter.dotDotDotToken !== undefined; });
+    if (restIndex === -1)
+        return;
+    var listType = markerType(state, targetType, "_flamework_send", node);
+    if (!listType)
+        return;
+    var args = node.arguments.map(function (argument) { return state.transformNode(argument); });
+    var leading = args.slice(0, restIndex);
+    var packed = args.slice(restIndex);
+    if (leading.some(typescript_1.default.isSpreadElement)) {
+        diagnostics_1.Diagnostics.error(node, "Flamework cannot pack this call: a spread argument ahead of the payload is not supported with networking.serialization enabled.");
+    }
+    var statements = new Array();
+    var chained = guardOptionalChain(state, statements, target, optionalTarget);
+    var transformedTarget = chained.target;
+    var leadingValues = leading.map(function (argument, index) {
+        return bindArgument(statements, argument, "target", emptyListAnnotation(state, node.arguments[index]));
+    });
+    var encoding;
+    if (packed.some(typescript_1.default.isSpreadElement)) {
+        // A spread makes the count a runtime matter: gather the list first, as `fire` itself would.
+        var table = factory_1.f.identifier("args", true);
+        statements.push(factory_1.f.variableStatement(table, factory_1.f.as(factory_1.f.array(packed, false), arrayType())));
+        encoding = (0, buildSerializerFromType_1.buildInlineEncoding)(state, node, listType, { table: table });
+    }
+    else {
+        var values = packed.map(function (argument) { return bindArgument(statements, argument, "arg"); });
+        encoding = (0, buildSerializerFromType_1.buildInlineEncoding)(state, node, listType, values);
+    }
+    statements.push.apply(statements, __spreadArray([], __read(encoding.statements), false));
+    var call = factory_1.f.call(factory_1.f.propertyAccessExpression(transformedTarget, factory_1.f.identifier(method)), __spreadArray(__spreadArray([], __read(leadingValues), false), __read(packedArguments(encoding)), false));
+    return emitWithStatements(state, node, statements, call, __spreadArray([target], __read(args), false), chained.wrap);
+}
+/**
+ * The target of a send or `setCallback`, evaluated ahead of the arguments the way the call would
+ * evaluate it: a plain read stays where it is, anything else is bound to a local first.
+ *
+ * A target reached through `?.` decides whether the call happens at all, so the packing has to
+ * stay behind that decision: the call is wrapped in a function (`wrap`) that returns `undefined`
+ * where the chain would short-circuit. The test goes on the operand ahead of each `?.` when every
+ * one of them is a reference, which keeps the narrowing the chain gave the arguments; otherwise
+ * the target is bound to a local and the test goes on that.
+ */
+function guardOptionalChain(state, statements, target, optionalTarget) {
+    var e_1, _a;
+    var transformedTarget = state.transformNode(target);
+    var operands = optionalOperands(target, optionalTarget);
+    if (operands.length > 0 && operands.every(isReference)) {
+        try {
+            for (var operands_1 = __values(operands), operands_1_1 = operands_1.next(); !operands_1_1.done; operands_1_1 = operands_1.next()) {
+                var operand = operands_1_1.value;
+                statements.push(shortCircuit(state.transformNode(operand)));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (operands_1_1 && !operands_1_1.done && (_a = operands_1.return)) _a.call(operands_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    else if (operands.length > 0) {
+        var bound_1 = bindArgument(statements, transformedTarget, "target");
+        statements.push(shortCircuit(bound_1));
+        return { target: bound_1, wrap: true };
+    }
+    var bound = isPure(target) ? transformedTarget : bindArgument(statements, transformedTarget, "target");
+    return { target: bound, wrap: operands.length > 0 };
+}
+/** `if (value === undefined) return undefined;` */
+function shortCircuit(value) {
+    return typescript_1.default.factory.createIfStatement(factory_1.f.binary(value, typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken, factory_1.f.nil()), factory_1.f.block([factory_1.f.returnStatement(factory_1.f.nil())]));
+}
+/**
+ * The operands ahead of each `?.` in `target`, outermost first, then `target` itself when the
+ * access after it is the optional one (`handler.x?.fire(...)`).
+ */
+function optionalOperands(target, optionalTarget) {
+    var operands = new Array();
+    var current = target;
+    while (typescript_1.default.isPropertyAccessExpression(current) ||
+        typescript_1.default.isElementAccessExpression(current) ||
+        typescript_1.default.isCallExpression(current) ||
+        typescript_1.default.isNonNullExpression(current)) {
+        if (!typescript_1.default.isNonNullExpression(current) && current.questionDotToken)
+            operands.unshift(current.expression);
+        current = current.expression;
+    }
+    if (optionalTarget)
+        operands.push(target);
+    return operands;
+}
+/** A reference TypeScript narrows: an identifier, `this`, or a property (or literal index) of one. */
+function isReference(node) {
+    if (typescript_1.default.isIdentifier(node) || node.kind === typescript_1.default.SyntaxKind.ThisKeyword)
+        return true;
+    if (typescript_1.default.isParenthesizedExpression(node) || typescript_1.default.isPropertyAccessExpression(node))
+        return isReference(node.expression);
+    if (typescript_1.default.isElementAccessExpression(node)) {
+        var index = node.argumentExpression;
+        return (typescript_1.default.isStringLiteral(index) || typescript_1.default.isNumericLiteral(index)) && isReference(node.expression);
+    }
+    return false;
+}
+/** `payload, blobs`, `payload`, or nothing at all when the list carries nothing. */
+function packedArguments(encoding) {
+    if (!encoding.payload)
+        return [];
+    return encoding.blobs ? [encoding.payload, encoding.blobs] : [encoding.payload];
+}
+/**
+ * The packing statements go ahead of the enclosing statement when that keeps them in the call's
+ * scope and runs them exactly when the call runs: once, unconditionally, and ahead of nothing that
+ * could tell the difference. Anywhere else -- behind `&&`, `||`, `??` or a conditional, in a loop
+ * condition, after a sibling with side effects, or inside an expression-bodied arrow, which has no
+ * statement of its own -- the call is wrapped in an immediately invoked function that holds them.
+ * `wrap` asks for that function outright: the statements then hold a short-circuit of their own.
+ */
+function emitWithStatements(state, node, statements, call, hoisted, wrap) {
+    if (wrap === void 0) { wrap = false; }
+    if (statements.length === 0)
+        return call;
+    if (wrap || !hoistsCleanly(node, hoisted)) {
+        return factory_1.f.call(factory_1.f.arrowFunction(factory_1.f.block(__spreadArray(__spreadArray([], __read(statements), false), [factory_1.f.returnStatement(call)], false))), []);
+    }
+    state.prereqList(statements);
+    return call;
+}
+/**
+ * Whether evaluating `hoisted` ahead of the statement that holds `node` is the same as evaluating it
+ * where `node` is: the position must be reached once and unconditionally, and whatever the
+ * statement evaluates before it must be unable to notice the difference -- plain reads on both
+ * sides, or nothing that reads at all on that side.
+ */
+function hoistsCleanly(node, hoisted) {
+    var ahead = new Array();
+    var child = node;
+    var parent = node.parent;
+    while (parent !== undefined && !typescript_1.default.isStatement(parent)) {
+        if (typescript_1.default.isFunctionLike(parent))
+            return false;
+        var before = evaluatedBefore(parent, child);
+        if (before === undefined)
+            return false;
+        ahead.push.apply(ahead, __spreadArray([], __read(before), false));
+        child = parent;
+        parent = parent.parent;
+    }
+    if (parent !== undefined && isRepeatedIn(parent, child))
+        return false;
+    if (!ahead.every(isPure))
+        return false;
+    return ahead.every(isConstant) || hoisted.every(isPure);
+}
+/**
+ * The expressions `parent` evaluates before `child` when `child` is evaluated once and
+ * unconditionally as part of it, or `undefined` when it is not (a short-circuited operand, a
+ * conditional branch, a `case` label) or the position is not one this understands.
+ */
+function evaluatedBefore(parent, child) {
+    var e_2, _a;
+    var _b;
+    if (typescript_1.default.isParenthesizedExpression(parent) ||
+        typescript_1.default.isAsExpression(parent) ||
+        typescript_1.default.isTypeAssertionExpression(parent) ||
+        typescript_1.default.isNonNullExpression(parent) ||
+        typescript_1.default.isSatisfiesExpression(parent) ||
+        typescript_1.default.isAwaitExpression(parent) ||
+        typescript_1.default.isYieldExpression(parent) ||
+        typescript_1.default.isVoidExpression(parent) ||
+        typescript_1.default.isTypeOfExpression(parent) ||
+        typescript_1.default.isDeleteExpression(parent) ||
+        typescript_1.default.isPrefixUnaryExpression(parent) ||
+        typescript_1.default.isSpreadElement(parent) ||
+        typescript_1.default.isSpreadAssignment(parent) ||
+        typescript_1.default.isTemplateSpan(parent)) {
+        return [];
+    }
+    if (typescript_1.default.isPropertyAccessExpression(parent)) {
+        return child === parent.expression ? [] : undefined;
+    }
+    if (typescript_1.default.isElementAccessExpression(parent)) {
+        return child === parent.expression ? [] : [parent.expression];
+    }
+    if (typescript_1.default.isCallExpression(parent) || typescript_1.default.isNewExpression(parent)) {
+        if (child === parent.expression)
+            return [];
+        var args = (_b = parent.arguments) !== null && _b !== void 0 ? _b : [];
+        var index = args.indexOf(child);
+        return index === -1 ? undefined : __spreadArray([parent.expression], __read(args.slice(0, index)), false);
+    }
+    if (typescript_1.default.isBinaryExpression(parent)) {
+        if (child === parent.left)
+            return [];
+        var operator = parent.operatorToken.kind;
+        if (operator === typescript_1.default.SyntaxKind.AmpersandAmpersandToken ||
+            operator === typescript_1.default.SyntaxKind.BarBarToken ||
+            operator === typescript_1.default.SyntaxKind.QuestionQuestionToken) {
+            return undefined;
+        }
+        if (!isAssignmentOperator(operator))
+            return [parent.left];
+        // An assignment target is not a value: what runs ahead of the right-hand side is the object
+        // (and index) it is stored into.
+        if (typescript_1.default.isIdentifier(parent.left))
+            return [];
+        if (typescript_1.default.isPropertyAccessExpression(parent.left))
+            return [parent.left.expression];
+        if (typescript_1.default.isElementAccessExpression(parent.left)) {
+            return [parent.left.expression, parent.left.argumentExpression];
+        }
+        return undefined;
+    }
+    if (typescript_1.default.isConditionalExpression(parent)) {
+        return child === parent.condition ? [] : undefined;
+    }
+    if (typescript_1.default.isArrayLiteralExpression(parent)) {
+        var index = parent.elements.indexOf(child);
+        return index === -1 ? undefined : parent.elements.slice(0, index);
+    }
+    if (typescript_1.default.isPropertyAssignment(parent)) {
+        if (child !== parent.initializer)
+            return undefined;
+        return typescript_1.default.isComputedPropertyName(parent.name) ? [parent.name.expression] : [];
+    }
+    if (typescript_1.default.isObjectLiteralExpression(parent)) {
+        var index = parent.properties.indexOf(child);
+        if (index === -1)
+            return undefined;
+        var before = new Array();
+        try {
+            for (var _c = __values(parent.properties.slice(0, index)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var property = _d.value;
+                if (typescript_1.default.isPropertyAssignment(property)) {
+                    if (typescript_1.default.isComputedPropertyName(property.name))
+                        before.push(property.name.expression);
+                    before.push(property.initializer);
+                }
+                else if (typescript_1.default.isShorthandPropertyAssignment(property)) {
+                    before.push(property.name);
+                }
+                else if (typescript_1.default.isSpreadAssignment(property)) {
+                    before.push(property.expression);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return before;
+    }
+    if (typescript_1.default.isTemplateExpression(parent)) {
+        var index = parent.templateSpans.indexOf(child);
+        return index === -1 ? undefined : parent.templateSpans.slice(0, index).map(function (span) { return span.expression; });
+    }
+    if (typescript_1.default.isVariableDeclaration(parent)) {
+        return child === parent.initializer ? [] : undefined;
+    }
+    if (typescript_1.default.isVariableDeclarationList(parent)) {
+        var index = parent.declarations.indexOf(child);
+        if (index === -1)
+            return undefined;
+        return parent.declarations
+            .slice(0, index)
+            .map(function (declaration) { return declaration.initializer; })
+            .filter(function (initializer) { return initializer !== undefined; });
+    }
+    return undefined;
+}
+/** Whether `statement` evaluates `child` on every pass of a loop rather than once on the way in. */
+function isRepeatedIn(statement, child) {
+    if (typescript_1.default.isWhileStatement(statement) || typescript_1.default.isDoStatement(statement))
+        return child === statement.expression;
+    if (typescript_1.default.isForStatement(statement))
+        return child === statement.condition || child === statement.incrementor;
+    return false;
+}
+/** An expression that evaluates without touching state: a literal, a closure, or a plain read. */
+function isPure(node) {
+    if (isConstant(node) || typescript_1.default.isIdentifier(node) || node.kind === typescript_1.default.SyntaxKind.ThisKeyword)
+        return true;
+    if (typescript_1.default.isPropertyAccessExpression(node))
+        return isPure(node.expression);
+    if (typescript_1.default.isElementAccessExpression(node))
+        return isPure(node.expression) && isPure(node.argumentExpression);
+    if (typescript_1.default.isParenthesizedExpression(node) ||
+        typescript_1.default.isAsExpression(node) ||
+        typescript_1.default.isTypeAssertionExpression(node) ||
+        typescript_1.default.isNonNullExpression(node) ||
+        typescript_1.default.isSatisfiesExpression(node) ||
+        typescript_1.default.isTypeOfExpression(node)) {
+        return isPure(node.expression);
+    }
+    if (typescript_1.default.isPrefixUnaryExpression(node)) {
+        var mutates = node.operator === typescript_1.default.SyntaxKind.PlusPlusToken || node.operator === typescript_1.default.SyntaxKind.MinusMinusToken;
+        return !mutates && isPure(node.operand);
+    }
+    if (typescript_1.default.isBinaryExpression(node)) {
+        return !isAssignmentOperator(node.operatorToken.kind) && isPure(node.left) && isPure(node.right);
+    }
+    if (typescript_1.default.isTemplateExpression(node))
+        return node.templateSpans.every(function (span) { return isPure(span.expression); });
+    if (typescript_1.default.isArrayLiteralExpression(node))
+        return node.elements.every(isPure);
+    if (typescript_1.default.isSpreadElement(node))
+        return isPure(node.expression);
+    if (typescript_1.default.isObjectLiteralExpression(node)) {
+        return node.properties.every(function (property) {
+            if (typescript_1.default.isPropertyAssignment(property)) {
+                var name_2 = property.name;
+                return (!typescript_1.default.isComputedPropertyName(name_2) || isPure(name_2.expression)) && isPure(property.initializer);
+            }
+            return !typescript_1.default.isSpreadAssignment(property) || isPure(property.expression);
+        });
+    }
+    return false;
+}
+/** `=` and the compound assignments, which TypeScript numbers in one run. */
+function isAssignmentOperator(operator) {
+    return operator >= typescript_1.default.SyntaxKind.FirstAssignment && operator <= typescript_1.default.SyntaxKind.LastAssignment;
+}
+/** An expression that reads nothing: a literal, a keyword, or a closure that is only being created. */
+function isConstant(node) {
+    return (typescript_1.default.isLiteralExpression(node) ||
+        node.kind === typescript_1.default.SyntaxKind.TrueKeyword ||
+        node.kind === typescript_1.default.SyntaxKind.FalseKeyword ||
+        node.kind === typescript_1.default.SyntaxKind.NullKeyword ||
+        typescript_1.default.isArrowFunction(node) ||
+        typescript_1.default.isFunctionExpression(node));
+}
+/**
+ * `handler.fn.setCallback(cb)` becomes `handler.fn._setCallback((lead..., a, b) => pack(cb(lead..., a, b)))`,
+ * where `pack` turns a successful result into `[payload, blobs?]` (or nothing, for a `void` result),
+ * follows a Promise if the callback returned one, and lets `Networking.Skip` through untouched.
+ */
+function transformReceiverCallback(state, node, target, targetType, optionalTarget) {
+    var _a;
+    var typeChecker = state.typeChecker;
+    var callbackArgument = node.arguments[0];
+    if (!callbackArgument)
+        return;
+    var listType = markerType(state, targetType, "_flamework_receive", node);
+    var fnType = markerType(state, targetType, "_flamework_fn", node);
+    if (!listType || !fnType)
+        return;
+    // How many arguments precede the list: the callback type is declared `(lead..., ...args: I) => ...`.
+    var signature = typeChecker.getResolvedSignature(node);
+    var declaration = signature === null || signature === void 0 ? void 0 : signature.declaration;
+    if (!declaration || !typescript_1.default.isFunctionLike(declaration))
+        return;
+    var callbackType = (_a = declaration.parameters[0]) === null || _a === void 0 ? void 0 : _a.type;
+    if (!callbackType || !typescript_1.default.isFunctionTypeNode(callbackType))
+        return;
+    var leadingCount = callbackType.parameters.filter(function (parameter) { return parameter.dotDotDotToken === undefined; }).length;
+    var statements = new Array();
+    // The callback keeps the parameter types `setCallback` would have given it: an arrow bound to a
+    // plain local would lose its contextual typing and end up with implicit `any` parameters.
+    var chained = guardOptionalChain(state, statements, target, optionalTarget);
+    var boundTarget = bindArgument(statements, chained.target, "target");
+    var callbackAnnotation = factory_1.f.indexedAccessType(factory_1.f.referenceType("Parameters", [factory_1.f.queryType(factory_1.f.qualifiedNameType(boundTarget, "setCallback"))]), factory_1.f.literalType(factory_1.f.number(0)));
+    var callback = factory_1.f.identifier("callback", true);
+    var transformedCallback = state.transformNode(callbackArgument);
+    statements.push(factory_1.f.variableStatement(callback, transformedCallback, callbackAnnotation));
+    // The wrapper mirrors the callback's parameters, so nothing is gathered into a table per call.
+    var parameters = new Array();
+    var forwarded = new Array();
+    for (var i = 0; i < leadingCount; i++) {
+        var id = factory_1.f.identifier("lead", true);
+        parameters.push(factory_1.f.parameterDeclaration(id, factory_1.f.keywordType(typescript_1.default.SyntaxKind.UnknownKeyword)));
+        forwarded.push(id);
+    }
+    if (typeChecker.isTupleType(listType)) {
+        var tuple = listType;
+        tuple.target.elementFlags.forEach(function (flags) {
+            var id = factory_1.f.identifier("arg", true);
+            if (flags & typescript_1.default.ElementFlags.Rest) {
+                parameters.push(factory_1.f.parameterDeclaration(id, arrayType(), undefined, false, true));
+                forwarded.push(typescript_1.default.factory.createSpreadElement(id));
+            }
+            else {
+                parameters.push(factory_1.f.parameterDeclaration(id, factory_1.f.keywordType(typescript_1.default.SyntaxKind.UnknownKeyword)));
+                forwarded.push(id);
+            }
+        });
+    }
+    var callable = factory_1.f.functionType([factory_1.f.parameterDeclaration("args", arrayType(), undefined, false, true)], factory_1.f.keywordType(typescript_1.default.SyntaxKind.UnknownKeyword));
+    var result = factory_1.f.identifier("result", true);
+    var body = new Array();
+    body.push(factory_1.f.variableStatement(result, factory_1.f.call(factory_1.f.as(callback, callable), forwarded)));
+    // A Promise is followed; its value is packed once it resolves.
+    var value = factory_1.f.identifier("value", true);
+    var packLater = factory_1.f.arrowFunction(factory_1.f.block(packResult(state, node, fnType, value, true)), [
+        factory_1.f.parameterDeclaration(value),
+    ]);
+    body.push(typescript_1.default.factory.createIfStatement(factory_1.f.call(factory_1.f.propertyAccessExpression(factory_1.f.identifier("Promise"), factory_1.f.identifier("is")), [result]), factory_1.f.block([factory_1.f.returnStatement(factory_1.f.call(factory_1.f.propertyAccessExpression(result, factory_1.f.identifier("then")), [packLater]))])));
+    body.push.apply(body, __spreadArray([], __read(packResult(state, node, fnType, result, false)), false));
+    var wrapper = factory_1.f.arrowFunction(factory_1.f.block(body), parameters);
+    var call = factory_1.f.call(factory_1.f.propertyAccessExpression(boundTarget, factory_1.f.identifier("_setCallback")), [wrapper]);
+    return emitWithStatements(state, node, statements, call, [target, transformedCallback], chained.wrap);
+}
+/**
+ * `if (v === Networking.Skip) return v; <pack v>; return [payload, blobs?]`, or `return undefined`
+ * when the result type carries nothing.
+ */
+function packResult(state, node, fnType, value, isParameter) {
+    var networking = state.addFileImport(state.getSourceFile(node), packages_1.NETWORKING_PACKAGE, "Networking");
+    var skip = factory_1.f.propertyAccessExpression(networking, factory_1.f.identifier("Skip"));
+    var encoding = (0, buildSerializerFromType_1.buildInlineResultEncoding)(state, node, fnType, value, isParameter);
+    var packed = packedArguments(encoding);
+    return __spreadArray(__spreadArray([
+        typescript_1.default.factory.createIfStatement(factory_1.f.binary(value, typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken, skip), factory_1.f.block([factory_1.f.returnStatement(value)]))
+    ], __read(encoding.statements), false), [
+        factory_1.f.returnStatement(packed.length > 0 ? factory_1.f.as(factory_1.f.array(packed, false), arrayType()) : factory_1.f.nil()),
+    ], false);
+}
+/** The type a hidden marker property carries, without the `undefined` its optionality adds. */
+function markerType(state, type, marker, node) {
+    var property = type.getProperty(marker);
+    if (!property)
+        return;
+    var markerType = state.typeChecker.getTypeOfSymbolAtLocation(property, node);
+    return state.typeChecker.getNonNullableType(markerType);
+}
+/**
+ * An argument that is read more than once is evaluated once, in call order, into a local. Identifiers
+ * and literals are returned as they are; anything else comes back as the new local's identifier.
+ */
+function bindArgument(statements, argument, hint, annotation) {
+    if (typescript_1.default.isIdentifier(argument) ||
+        typescript_1.default.isLiteralExpression(argument) ||
+        argument.kind === typescript_1.default.SyntaxKind.TrueKeyword ||
+        argument.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+        return argument;
+    }
+    var id = factory_1.f.identifier(hint, true);
+    statements.push(factory_1.f.variableStatement(id, argument, annotation));
+    return id;
+}
+/**
+ * `const target = []` is an implicit `any[]`, which a project compiled with `noImplicitAny` rejects: an
+ * empty list (`fire([], value)`) is bound with the type its context gave it.
+ */
+function emptyListAnnotation(state, original) {
+    if (!original || !typescript_1.default.isArrayLiteralExpression(original) || original.elements.length > 0)
+        return;
+    var type = state.typeChecker.getContextualType(original);
+    if (!type)
+        return;
+    return state.typeChecker.typeToTypeNode(type, original, typescript_1.default.NodeBuilderFlags.IgnoreErrors | typescript_1.default.NodeBuilderFlags.NoTruncation);
+}
+function arrayType() {
+    return factory_1.f.referenceType("Array", [factory_1.f.keywordType(typescript_1.default.SyntaxKind.UnknownKeyword)]);
+}

package/out/transformations/transformNode.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformNode = transformNode;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../classes/diagnostics");
+var transformExpression_1 = require("./transformExpression");
+var transformStatement_1 = require("./transformStatement");
+function transformNode(state, node) {
+    try {
+        if (typescript_1.default.isExpression(node)) {
+            return (0, transformExpression_1.transformExpression)(state, node);
+        }
+        else if (typescript_1.default.isStatement(node)) {
+            return (0, transformStatement_1.transformStatement)(state, node);
+        }
+    }
+    catch (e) {
+        if (e instanceof Error && !("diagnostic" in e)) {
+            diagnostics_1.Diagnostics.error(node, "Flamework failure occurred here\n".concat(e.stack));
+        }
+        throw e;
+    }
+    return typescript_1.default.visitEachChild(node, function (newNode) { return transformNode(state, newNode); }, state.context);
+}

package/out/transformations/transformStatement.js

@@ -0,0 +1,57 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStatement = transformStatement;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnosticsUtils_1 = require("../util/diagnosticsUtils");
+var getNodeList_1 = require("../util/functions/getNodeList");
+var transformClassDeclaration_1 = require("./statements/transformClassDeclaration");
+var transformNode_1 = require("./transformNode");
+var factory_1 = require("../util/factory");
+var TRANSFORMERS = new Map([
+    [typescript_1.default.SyntaxKind.ClassDeclaration, transformClassDeclaration_1.transformClassDeclaration],
+]);
+function transformStatement(state, statement) {
+    return (0, diagnosticsUtils_1.catchDiagnostic)(statement, function () {
+        var _a = __read(state.capture(function () {
+            var transformer = TRANSFORMERS.get(statement.kind);
+            if (transformer) {
+                return transformer(state, statement);
+            }
+            return typescript_1.default.visitEachChild(statement, function (newNode) { return (0, transformNode_1.transformNode)(state, newNode); }, state.context);
+        }), 2), node = _a[0], prereqs = _a[1];
+        if (factory_1.f.is.file(statement.parent)) {
+            var nextRootStatements = state.nextRootStatements;
+            state.nextRootStatements = [];
+            return __spreadArray(__spreadArray(__spreadArray([], __read(nextRootStatements), false), __read(prereqs), false), __read((0, getNodeList_1.getNodeList)(node)), false);
+        }
+        return __spreadArray(__spreadArray([], __read(prereqs), false), __read((0, getNodeList_1.getNodeList)(node)), false);
+    });
+}