@flamework-experimental/transformer 2.0.0-alpha.0

package/out/transformations/macros/intrinsics/parameters.js

@@ -0,0 +1,81 @@
+"use strict";
+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.validateParameterConstIntrinsic = validateParameterConstIntrinsic;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../../classes/diagnostics");
+/**
+ * Validates that the specified parameters can be inspected at compile-time (up to a depth of 1)
+ */
+function validateParameterConstIntrinsic(node, signature, parameters) {
+    var e_1, _a;
+    var _b, _c;
+    var _loop_1 = function (parameter) {
+        var e_2, _d;
+        var parameterIndex = signature.parameters.findIndex(function (v) { var _a; return ((_a = v.valueDeclaration) === null || _a === void 0 ? void 0 : _a.symbol) === parameter; });
+        var argument = (_b = node.arguments) === null || _b === void 0 ? void 0 : _b[parameterIndex];
+        if (!argument) {
+            return "continue";
+        }
+        // Check if the argument is a literal (string, number, etc)
+        if (typescript_1.default.isLiteralExpression(argument)) {
+            return "continue";
+        }
+        var elements = typescript_1.default.isObjectLiteralExpression(argument)
+            ? argument.properties
+            : typescript_1.default.isArrayLiteralExpression(argument)
+                ? argument.elements
+                : undefined;
+        var parameterDiagnostic = diagnostics_1.Diagnostics.createDiagnostic((_c = parameter.valueDeclaration) !== null && _c !== void 0 ? _c : argument, typescript_1.default.DiagnosticCategory.Message, "Required because this parameter must be known at compile-time.");
+        // This argument is not an object or array literal.
+        if (!elements) {
+            var baseDiagnostic = diagnostics_1.Diagnostics.createDiagnostic(argument, typescript_1.default.DiagnosticCategory.Error, "Flamework expected this argument to be a literal expression.");
+            typescript_1.default.addRelatedInfo(baseDiagnostic, parameterDiagnostic);
+            throw new diagnostics_1.DiagnosticError(baseDiagnostic);
+        }
+        try {
+            // We also want to validate that there are no spread operations inside the literal.
+            for (var elements_1 = (e_2 = void 0, __values(elements)), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+                var element = elements_1_1.value;
+                if (typescript_1.default.isSpreadElement(element) || typescript_1.default.isSpreadAssignment(element)) {
+                    var baseDiagnostic = diagnostics_1.Diagnostics.createDiagnostic(element, typescript_1.default.DiagnosticCategory.Error, "Flamework does not support spread expressions in this location.");
+                    typescript_1.default.addRelatedInfo(baseDiagnostic, parameterDiagnostic);
+                    throw new diagnostics_1.DiagnosticError(baseDiagnostic);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (elements_1_1 && !elements_1_1.done && (_d = elements_1.return)) _d.call(elements_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    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;
+            _loop_1(parameter);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parameters_1_1 && !parameters_1_1.done && (_a = parameters_1.return)) _a.call(parameters_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}

package/out/transformations/macros/intrinsics/paths.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathGlobIntrinsic = buildPathGlobIntrinsic;
+exports.buildPathIntrinsic = buildPathIntrinsic;
+var path_1 = __importDefault(require("path"));
+var factory_1 = require("../../../util/factory");
+var diagnostics_1 = require("../../../classes/diagnostics");
+/**
+ * Generates a path glob.
+ *
+ * This generates a string as a reference to the runtime metadata exposed in core.
+ */
+function buildPathGlobIntrinsic(state, node, pathType) {
+    if (!pathType.isStringLiteral()) {
+        diagnostics_1.Diagnostics.error(node, "Path is invalid, expected string literal and got: ".concat(state.typeChecker.typeToString(pathType)));
+    }
+    var file = state.getSourceFile(node);
+    var glob = pathType.value;
+    var absoluteGlob = glob.startsWith(".")
+        ? path_1.default.relative(state.rootDirectory, path_1.default.resolve(path_1.default.dirname(file.fileName), glob)).replace(/\\/g, "/")
+        : glob;
+    state.buildInfo.addGlob(absoluteGlob, state.getFileId(file));
+    return factory_1.f.string(state.obfuscateText(absoluteGlob, "addPaths"));
+}
+/**
+ * Generates a path as an array of Rojo path segments.
+ */
+function buildPathIntrinsic(state, node, pathType) {
+    var _a;
+    if (!pathType.isStringLiteral()) {
+        diagnostics_1.Diagnostics.error(node, "Path is invalid, expected string literal and got: ".concat(state.typeChecker.typeToString(pathType)));
+    }
+    var outputPath = state.pathTranslator.getOutputPath(pathType.value);
+    var rbxPath = (_a = state.rojoResolver) === null || _a === void 0 ? void 0 : _a.getRbxPathFromFilePath(outputPath);
+    if (!rbxPath) {
+        diagnostics_1.Diagnostics.error(node, "Could not find Rojo data for '".concat(pathType.value, "'"));
+    }
+    return factory_1.f.array(rbxPath.map(factory_1.f.string));
+}

package/out/transformations/macros/updateComponentConfig.js

@@ -0,0 +1,409 @@
+"use strict";
+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 __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.updateComponentConfig = updateComponentConfig;
+var typescript_1 = __importDefault(require("typescript"));
+var buildGuardFromType_1 = require("../../util/functions/buildGuardFromType");
+var factory_1 = require("../../util/factory");
+var getSuperClasses_1 = require("../../util/functions/getSuperClasses");
+var nodeMetadata_1 = require("../../classes/nodeMetadata");
+var diagnosticsUtils_1 = require("../../util/diagnosticsUtils");
+var getInstanceTypeFromType_1 = require("../../util/functions/getInstanceTypeFromType");
+var diagnostics_1 = require("../../classes/diagnostics");
+var uid_1 = require("../../util/uid");
+var buildInstanceShape_1 = require("../../util/functions/buildInstanceShape");
+/**
+ * The property every component carries, which is how a component type is told apart from the
+ * Instance types around it.
+ */
+var COMPONENT_BRAND = "_flamework_link_instance";
+/**
+ * Reads one of `BaseComponent`'s type parameters through the property that carries it, so that a
+ * subclass gets the instantiated type and an unrelated class gets nothing.
+ */
+function getMarkedType(state, node, property, marker) {
+    var type = state.typeChecker.getTypeAtLocation(node);
+    var symbol = type.getProperty(property);
+    if (!symbol)
+        return;
+    var metadata = nodeMetadata_1.NodeMetadata.fromSymbol(state, symbol);
+    if (!metadata || !metadata.isRequested(marker))
+        return;
+    return state.typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+}
+function calculateOmittedGuards(state, classDeclaration, customAttributes) {
+    var e_1, _a, e_2, _b;
+    var omittedNames = new Set();
+    if (factory_1.f.is.propertyAssignmentDeclaration(customAttributes) && factory_1.f.is.object(customAttributes.initializer)) {
+        try {
+            for (var _c = __values(customAttributes.initializer.properties), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var prop = _d.value;
+                if (factory_1.f.is.string(prop.name) || factory_1.f.is.identifier(prop.name)) {
+                    omittedNames.add(prop.name.text);
+                }
+            }
+        }
+        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; }
+        }
+    }
+    var type = state.typeChecker.getTypeAtLocation(classDeclaration);
+    var property = type.getProperty("_flamework_attribute_guards");
+    if (!property)
+        return omittedNames;
+    var superClass = (0, getSuperClasses_1.getSuperClasses)(state.typeChecker, classDeclaration)[0];
+    if (!superClass)
+        return omittedNames;
+    var superType = state.typeChecker.getTypeAtLocation(superClass);
+    var superProperty = superType.getProperty("_flamework_attribute_guards");
+    if (!superProperty)
+        return omittedNames;
+    var attributes = state.typeChecker.getTypeOfSymbolAtLocation(property, classDeclaration);
+    var superAttributes = state.typeChecker.getTypeOfSymbolAtLocation(superProperty, superClass);
+    try {
+        for (var _e = __values(superAttributes.getProperties()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var name_1 = _f.value.name;
+            var prop = state.typeChecker.getTypeOfPropertyOfType(attributes, name_1);
+            var superProp = state.typeChecker.getTypeOfPropertyOfType(superAttributes, name_1);
+            if (prop && superProp && superProp === prop) {
+                omittedNames.add(name_1);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return omittedNames;
+}
+function updateAttributeGuards(state, node, properties) {
+    var _a;
+    // The guards come from the written shape of the attributes rather than the declared one: an
+    // instance-valued attribute is stored as an `InstanceHandle`, so that is what is checked.
+    var attributesType = getMarkedType(state, node, "_flamework_attribute_guards", "intrinsic-component-attribute-guards");
+    if (!attributesType)
+        return;
+    var attributes = properties.find(function (x) { return x.name && "text" in x.name && x.name.text === "attributes"; });
+    var attributeGuards = (0, diagnosticsUtils_1.withDiagnosticContext)((_a = node.name) !== null && _a !== void 0 ? _a : node, function () { return "Failed to generate component attributes: ".concat(state.typeChecker.typeToString(attributesType)); }, function () { var _a; return (0, buildGuardFromType_1.buildGuardsFromType)(state, (_a = node.name) !== null && _a !== void 0 ? _a : node, attributesType); });
+    var omittedGuards = calculateOmittedGuards(state, node, attributes);
+    var filteredGuards = attributeGuards.filter(function (x) { return !omittedGuards.has(x.name.text); });
+    properties = properties.filter(function (x) { return x !== attributes; });
+    if (factory_1.f.is.propertyAssignmentDeclaration(attributes) && factory_1.f.is.object(attributes.initializer)) {
+        properties.push(factory_1.f.update.propertyAssignmentDeclaration(attributes, factory_1.f.update.object(attributes.initializer, __spreadArray(__spreadArray([], __read(attributes.initializer.properties.map(function (v) { return state.transformNode(v); })), false), __read(filteredGuards), false)), attributes.name));
+    }
+    else {
+        properties.push(factory_1.f.propertyAssignmentDeclaration("attributes", factory_1.f.object(filteredGuards)));
+    }
+    return properties;
+}
+function updateInstanceGuard(state, node, properties) {
+    var type = state.typeChecker.getTypeAtLocation(node);
+    var property = type.getProperty("instance");
+    if (!property)
+        return;
+    var attributesMeta = nodeMetadata_1.NodeMetadata.fromSymbol(state, property);
+    if (!attributesMeta || !attributesMeta.isRequested("intrinsic-component-instance"))
+        return;
+    var superClass = (0, getSuperClasses_1.getSuperClasses)(state.typeChecker, node)[0];
+    if (!superClass)
+        return;
+    var customGuard = properties.find(function (x) { return x.name && "text" in x.name && x.name.text === "instanceGuard"; });
+    if (customGuard)
+        return;
+    var instanceType = state.typeChecker.getTypeOfSymbolAtLocation(property, node);
+    if (!instanceType)
+        return;
+    var superType = state.typeChecker.getTypeAtLocation(superClass);
+    var superProperty = superType.getProperty("instance");
+    if (!superProperty)
+        return;
+    var superInstanceType = state.typeChecker.getTypeOfSymbolAtLocation(superProperty, superClass);
+    if (!superInstanceType)
+        return;
+    if (!type.checker.isTypeAssignableTo(superInstanceType, instanceType)) {
+        // As data wherever the type is only classes and children, which the runtime watches one
+        // child at a time and can explain; as a guard otherwise. A child naming a component has a
+        // tree of its own that is that component's business, so the shape stops at its class.
+        var shape = (0, buildInstanceShape_1.buildInstanceShape)(state, node, instanceType, getComponentChildNames(state, node));
+        if (shape !== undefined) {
+            properties.push(factory_1.f.propertyAssignmentDeclaration("instanceShape", shape));
+        }
+        else {
+            properties.push(factory_1.f.propertyAssignmentDeclaration("instanceGuard", (0, buildGuardFromType_1.buildGuardFromType)(state, node, instanceType)));
+        }
+    }
+    return properties;
+}
+/**
+ * The instance a component type is attached to, or nothing when the type is not a component. This
+ * is the resolved tree rather than the declared one, so a linked component's own children are part
+ * of the guard.
+ */
+function getComponentInstanceType(state, type, node) {
+    if (!type.getProperty(COMPONENT_BRAND))
+        return;
+    var instance = type.getProperty("instance");
+    if (!instance)
+        return;
+    return state.typeChecker.getTypeOfSymbolAtLocation(instance, node);
+}
+/**
+ * The members of an instance type that are not part of the Roblox class itself, which is how the
+ * guard builder reads an intersection: as the children the instance must have.
+ */
+function getDeclaredChildren(state, node, type) {
+    var e_3, _a;
+    var instanceType = (0, getInstanceTypeFromType_1.getInstanceTypeFromType)(node.getSourceFile(), type);
+    var children = new Array();
+    try {
+        for (var _b = __values(type.getProperties()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var property = _c.value;
+            if (instanceType.getProperty(property.name))
+                continue;
+            var propertyType = state.typeChecker.getTypeOfSymbolAtLocation(property, node);
+            if (propertyType)
+                children.push([property, propertyType]);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return children;
+}
+function isOptionalMember(state, symbol, type) {
+    return (symbol.flags & typescript_1.default.SymbolFlags.Optional) !== 0 || state.typeChecker.getNonNullableType(type) !== type;
+}
+function createLink(state, node, kind, name, optional, componentType, guardType) {
+    var _a, _b, _c;
+    var fields = [
+        factory_1.f.propertyAssignmentDeclaration("kind", kind),
+        factory_1.f.propertyAssignmentDeclaration("name", name),
+        factory_1.f.propertyAssignmentDeclaration("optional", optional),
+    ];
+    if (guardType) {
+        var shape = (0, buildInstanceShape_1.buildInstanceShape)(state, (_a = node.name) !== null && _a !== void 0 ? _a : node, guardType);
+        fields.push(shape !== undefined
+            ? factory_1.f.propertyAssignmentDeclaration("shape", shape)
+            : factory_1.f.propertyAssignmentDeclaration("guard", (0, diagnosticsUtils_1.withDiagnosticContext)((_b = node.name) !== null && _b !== void 0 ? _b : node, function () { return "Failed to generate a guard for the '".concat(name, "' link"); }, function () { var _a; return (0, buildGuardFromType_1.buildGuardFromType)(state, (_a = node.name) !== null && _a !== void 0 ? _a : node, guardType); })));
+    }
+    if (componentType) {
+        fields.push(factory_1.f.propertyAssignmentDeclaration("component", (0, uid_1.getTypeUid)(state, componentType, (_c = node.name) !== null && _c !== void 0 ? _c : node)));
+    }
+    return factory_1.f.object(fields, false);
+}
+/**
+ * The direct children of the declared tree that name a component. Their trees belong to that
+ * component -- its tracker checks and watches them -- so the owner's shape stops at their class.
+ */
+function getComponentChildNames(state, node) {
+    var e_4, _a;
+    var names = new Set();
+    var instanceType = getMarkedType(state, node, COMPONENT_BRAND, "intrinsic-component-instance-links");
+    if (!instanceType)
+        return names;
+    try {
+        for (var _b = __values(getDeclaredChildren(state, node, instanceType)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), property = _d[0], declaredType = _d[1];
+            var targetType = state.typeChecker.getNonNullableType(declaredType);
+            if (getComponentInstanceType(state, targetType, node))
+                names.add(property.name);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return names;
+}
+/**
+ * Discovers the components and instances a component links to, from the attributes it declares and
+ * from its instance tree. `Components` waits for each one and keeps it resolved.
+ */
+function updateLinks(state, node, properties) {
+    var e_5, _a, e_6, _b;
+    var attributesType = getMarkedType(state, node, "_flamework_link_attributes", "intrinsic-component-attribute-links");
+    var instanceType = getMarkedType(state, node, COMPONENT_BRAND, "intrinsic-component-instance-links");
+    if (!attributesType && !instanceType)
+        return;
+    var links = new Array();
+    if (attributesType) {
+        try {
+            for (var _c = __values(attributesType.getProperties()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var property = _d.value;
+                var declaredType = state.typeChecker.getTypeOfSymbolAtLocation(property, node);
+                var targetType = state.typeChecker.getNonNullableType(declaredType);
+                var optional = isOptionalMember(state, property, declaredType);
+                if (getComponentInstanceType(state, targetType, node)) {
+                    // No guard or shape of its own: the instance a component link names has to carry
+                    // that component, and that component's tracker is what checks its tree.
+                    links.push(createLink(state, node, "attribute", property.name, optional, targetType));
+                }
+                else if ((0, buildGuardFromType_1.isInstanceType)(targetType)) {
+                    links.push(createLink(state, node, "attribute", property.name, optional, undefined, targetType));
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    }
+    if (instanceType) {
+        try {
+            for (var _e = __values(getDeclaredChildren(state, node, instanceType)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var _g = __read(_f.value, 2), property = _g[0], declaredType = _g[1];
+                var targetType = state.typeChecker.getNonNullableType(declaredType);
+                var optional = isOptionalMember(state, property, declaredType);
+                if (getComponentInstanceType(state, targetType, node)) {
+                    // A child's own guard is part of the component's instance guard, so the link only
+                    // has to name the component that must exist on it.
+                    links.push(createLink(state, node, "child", property.name, optional, targetType));
+                }
+                else if ((0, buildGuardFromType_1.isInstanceType)(targetType)) {
+                    if (optional)
+                        assertChildIsRequired(node, property, property.name);
+                    assertInstanceTree(state, node, targetType, property.name);
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    }
+    if (links.length !== 0) {
+        properties.push(factory_1.f.propertyAssignmentDeclaration("links", factory_1.f.array(links)));
+    }
+    return properties;
+}
+/**
+ * The node a diagnostic about a declared child belongs on, which is the child itself wherever it
+ * was written down, and the component otherwise.
+ */
+function getPropertyNode(node, property) {
+    var _a, _b, _c;
+    var declaration = (_a = property.valueDeclaration) !== null && _a !== void 0 ? _a : (_b = property.declarations) === null || _b === void 0 ? void 0 : _b[0];
+    if (!declaration)
+        return (_c = node.name) !== null && _c !== void 0 ? _c : node;
+    return factory_1.f.is.namedDeclaration(declaration) ? declaration.name : declaration;
+}
+/**
+ * A child of the instance tree cannot be optional. `this.instance.Head` is an index into the
+ * instance itself, and Roblox raises on a child that is not there rather than handing back nothing,
+ * so the optional type would promise a read that is not safe to make.
+ *
+ * A child typed as a *component* is the exception, and is let through above: it is a link, so its
+ * presence is watched and `childComponents.Head` -- an ordinary table read -- is what says whether
+ * the child is there.
+ */
+function assertChildIsRequired(node, property, path) {
+    var component = node.name ? " of '".concat(node.name.text, "'") : "";
+    // Naming a component is only an option for a direct child; one deeper in the tree cannot be
+    // linked at all, so it is not offered as a way out there.
+    var link = path.includes(".")
+        ? ""
+        : " type it as a component so that Flamework watches it and 'childComponents' says whether it is there, or";
+    diagnostics_1.Diagnostics.error(getPropertyNode(node, property), "Child '".concat(path, "' of the instance tree").concat(component, " is optional, which Flamework does not allow: Roblox raises when a child that does not exist is indexed, so 'this.instance.").concat(path, "' would error rather than be undefined."), "Require the child,".concat(link, " leave it out of the tree and reach for it with FindFirstChild."));
+}
+/**
+ * Checks the children declared below a direct child of the instance tree.
+ *
+ * A component deeper in the tree cannot be linked: `this.instance` only resolves components it
+ * holds directly, and the guard builder would meet the class itself. Saying so here beats the
+ * "Flamework does not support generating guards for classes" that would follow. An optional child
+ * is refused at every depth, for the same reason it is refused at the top.
+ */
+function assertInstanceTree(state, node, type, path) {
+    var e_7, _a;
+    var _b;
+    try {
+        for (var _c = __values(getDeclaredChildren(state, node, type)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), property = _e[0], declaredType = _e[1];
+            var targetType = state.typeChecker.getNonNullableType(declaredType);
+            var childPath = "".concat(path, ".").concat(property.name);
+            if (targetType.getProperty(COMPONENT_BRAND)) {
+                diagnostics_1.Diagnostics.error((_b = node.name) !== null && _b !== void 0 ? _b : node, "Component '".concat(state.typeChecker.typeToString(targetType), "' is linked at '").concat(childPath, "', which is not a direct child of this component."), "Only a direct child of the instance tree can name a component. Declare it on the component attached to that child, or look it up with getComponent.");
+            }
+            if ((0, buildGuardFromType_1.isInstanceType)(targetType)) {
+                if (isOptionalMember(state, property, declaredType)) {
+                    assertChildIsRequired(node, property, childPath);
+                }
+                assertInstanceTree(state, node, targetType, childPath);
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+}
+function updateComponentConfig(state, node, properties) {
+    var _a, _b, _c;
+    // Links first: they are what reports a component the guards cannot be generated for, and that
+    // reads far better than the "cannot generate a guard for a class" the guards would raise.
+    properties = (_a = updateLinks(state, node, properties)) !== null && _a !== void 0 ? _a : properties;
+    properties = (_b = updateAttributeGuards(state, node, properties)) !== null && _b !== void 0 ? _b : properties;
+    properties = (_c = updateInstanceGuard(state, node, properties)) !== null && _c !== void 0 ? _c : properties;
+    return properties;
+}