@flamework-experimental/transformer 2.0.0-alpha.0

package/out/transformations/plugins/nodeFactory.js

@@ -0,0 +1,159 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapNode = unwrapNode;
+exports.createNodeFactory = createNodeFactory;
+exports.createNodeHandle = handle;
+var typescript_1 = __importDefault(require("typescript"));
+var factory_1 = require("../../util/factory");
+/**
+ * Plugins build nodes through this factory rather than touching `ts.factory`, so the emitted AST
+ * stays valid regardless of what a plugin does. Each returned handle is an opaque `Node` whose
+ * underlying `ts.Node` is recovered with {@link unwrapNode}.
+ */
+var NODES = new WeakMap();
+function handle(node) {
+    var result = {};
+    NODES.set(result, node);
+    return result;
+}
+function unwrapNode(node) {
+    var result = NODES.get(node);
+    if (!result) {
+        throw new Error("received a Node that was not created by this transformer's factory");
+    }
+    return result;
+}
+function expression(node) {
+    var result = unwrapNode(node);
+    if (!typescript_1.default.isExpression(result)) {
+        throw new Error("expected an expression, got ".concat(typescript_1.default.SyntaxKind[result.kind]));
+    }
+    return result;
+}
+function statement(node) {
+    var result = unwrapNode(node);
+    if (!typescript_1.default.isStatement(result)) {
+        throw new Error("expected a statement, got ".concat(typescript_1.default.SyntaxKind[result.kind]));
+    }
+    return result;
+}
+var BINARY_OPERATORS = {
+    "+": typescript_1.default.SyntaxKind.PlusToken,
+    "-": typescript_1.default.SyntaxKind.MinusToken,
+    "*": typescript_1.default.SyntaxKind.AsteriskToken,
+    "/": typescript_1.default.SyntaxKind.SlashToken,
+    "%": typescript_1.default.SyntaxKind.PercentToken,
+    "==": typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken,
+    "!=": typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken,
+    "<": typescript_1.default.SyntaxKind.LessThanToken,
+    "<=": typescript_1.default.SyntaxKind.LessThanEqualsToken,
+    ">": typescript_1.default.SyntaxKind.GreaterThanToken,
+    ">=": typescript_1.default.SyntaxKind.GreaterThanEqualsToken,
+    "&&": typescript_1.default.SyntaxKind.AmpersandAmpersandToken,
+    "||": typescript_1.default.SyntaxKind.BarBarToken,
+    "??": typescript_1.default.SyntaxKind.QuestionQuestionToken,
+};
+function createNodeFactory() {
+    return {
+        expr: {
+            string: function (value) { return handle(factory_1.f.string(value)); },
+            number: function (value) {
+                return handle(value < 0
+                    ? typescript_1.default.factory.createPrefixUnaryExpression(typescript_1.default.SyntaxKind.MinusToken, typescript_1.default.factory.createNumericLiteral(-value))
+                    : typescript_1.default.factory.createNumericLiteral(value));
+            },
+            bool: function (value) { return handle(value ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse()); },
+            nil: function () { return handle(typescript_1.default.factory.createIdentifier("undefined")); },
+            identifier: function (name, unique) {
+                return handle(unique
+                    ? typescript_1.default.factory.createUniqueName(name, typescript_1.default.GeneratedIdentifierFlags.Optimistic)
+                    : typescript_1.default.factory.createIdentifier(name));
+            },
+            array: function (values) { return handle(typescript_1.default.factory.createArrayLiteralExpression(values.map(expression))); },
+            object: function (fields) {
+                var entries = Array.isArray(fields)
+                    ? fields
+                    : Object.entries(fields).map(function (_a) {
+                        var _b = __read(_a, 2), name = _b[0], value = _b[1];
+                        return ({ name: name, value: value });
+                    });
+                return handle(typescript_1.default.factory.createObjectLiteralExpression(entries.map(function (v) {
+                    return typescript_1.default.factory.createPropertyAssignment(createPropertyName(v.name), expression(v.value));
+                }), true));
+            },
+            call: function (target, args) {
+                return handle(typescript_1.default.factory.createCallExpression(expression(target), undefined, (args !== null && args !== void 0 ? args : []).map(expression)));
+            },
+            new: function (target, args) {
+                return handle(typescript_1.default.factory.createNewExpression(expression(target), undefined, (args !== null && args !== void 0 ? args : []).map(expression)));
+            },
+            property: function (target, name) {
+                return handle(typescript_1.default.factory.createPropertyAccessExpression(expression(target), name));
+            },
+            element: function (target, index) {
+                return handle(typescript_1.default.factory.createElementAccessExpression(expression(target), expression(index)));
+            },
+            binary: function (left, operator, right) {
+                var token = BINARY_OPERATORS[operator];
+                if (token === undefined) {
+                    throw new Error("unsupported binary operator '".concat(operator, "'"));
+                }
+                return handle(typescript_1.default.factory.createBinaryExpression(expression(left), token, expression(right)));
+            },
+            not: function (value) {
+                return handle(typescript_1.default.factory.createPrefixUnaryExpression(typescript_1.default.SyntaxKind.ExclamationToken, expression(value)));
+            },
+            conditional: function (condition, whenTrue, whenFalse) {
+                return handle(typescript_1.default.factory.createConditionalExpression(expression(condition), undefined, expression(whenTrue), undefined, expression(whenFalse)));
+            },
+            arrow: function (parameters, body) {
+                return handle(typescript_1.default.factory.createArrowFunction(undefined, undefined, parameters.map(function (name) {
+                    return typescript_1.default.factory.createParameterDeclaration(undefined, undefined, name, undefined, undefined);
+                }), undefined, undefined, Array.isArray(body)
+                    ? typescript_1.default.factory.createBlock(body.map(statement), true)
+                    : expression(body)));
+            },
+            parenthesize: function (value) { return handle(typescript_1.default.factory.createParenthesizedExpression(expression(value))); },
+        },
+        stmt: {
+            variable: function (name, value) {
+                return handle(typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([
+                    typescript_1.default.factory.createVariableDeclaration(expression(name), undefined, undefined, expression(value)),
+                ], typescript_1.default.NodeFlags.Const)));
+            },
+            expression: function (value) { return handle(typescript_1.default.factory.createExpressionStatement(expression(value))); },
+            return: function (value) {
+                return handle(typescript_1.default.factory.createReturnStatement(value ? expression(value) : undefined));
+            },
+            block: function (statements) { return handle(typescript_1.default.factory.createBlock(statements.map(statement), true)); },
+            if: function (condition, whenTrue, whenFalse) {
+                return handle(typescript_1.default.factory.createIfStatement(expression(condition), statement(whenTrue), whenFalse ? statement(whenFalse) : undefined));
+            },
+        },
+    };
+}
+/**
+ * Object keys that are not valid identifiers have to be emitted as string literals.
+ */
+function createPropertyName(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? typescript_1.default.factory.createIdentifier(name) : factory_1.f.string(name);
+}

package/out/transformations/plugins/pluginHost.js

@@ -0,0 +1,235 @@
+"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.createPluginHost = createPluginHost;
+var path_1 = __importDefault(require("path"));
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../classes/diagnostics");
+var factory_1 = require("../../util/factory");
+var nodeFactory_1 = require("./nodeFactory");
+var typeFacade_1 = require("./typeFacade");
+var packages_1 = require("../../util/packages");
+/**
+ * The callbacks each plugin module registered when it was first loaded, keyed by its resolved path.
+ *
+ * Node caches modules, so requiring a plugin a second time does not run its top level again and
+ * registers nothing. A transformer state is created for every compilation -- every rebuild in watch
+ * mode -- so the callbacks have to outlive the state that first loaded them.
+ */
+var LOADED_PLUGINS = new Map();
+/**
+ * Loads and drives Flamework transformer plugins.
+ *
+ * Plugins are ordinary CommonJS modules loaded into the compiler process -- they are build-time
+ * code the project already trusts, exactly like the transformer itself. The `Type` and `Node`
+ * facades exist to give plugins an API that survives TypeScript upgrades, not to sandbox them.
+ */
+function createPluginHost(state) {
+    var e_1, _a;
+    var _b;
+    var pluginConfigs = state.config.plugins;
+    if (!pluginConfigs || pluginConfigs.length === 0) {
+        return;
+    }
+    // Loaded lazily so that projects without plugins never pay for resolving the plugin module.
+    var registry = requirePluginRegistry(state);
+    var types = (0, typeFacade_1.createTypeFactory)(state);
+    var factory = (0, nodeFactory_1.createNodeFactory)();
+    var macroTypes = new Map();
+    var cache = new Map();
+    try {
+        for (var pluginConfigs_1 = __values(pluginConfigs), pluginConfigs_1_1 = pluginConfigs_1.next(); !pluginConfigs_1_1.done; pluginConfigs_1_1 = pluginConfigs_1.next()) {
+            var pluginConfig = pluginConfigs_1_1.value;
+            var normalized = typeof pluginConfig === "string" ? { path: pluginConfig } : pluginConfig;
+            loadPlugin(normalized.path, (_b = normalized.options) !== null && _b !== void 0 ? _b : {});
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (pluginConfigs_1_1 && !pluginConfigs_1_1.done && (_a = pluginConfigs_1.return)) _a.call(pluginConfigs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { executeMacroType: executeMacroType, getRegisteredMacroTypes: function () { return __spreadArray([], __read(macroTypes.keys()), false); } };
+    function loadPlugin(pluginPath, options) {
+        var e_2, _a;
+        var resolved = resolvePluginPath(state, pluginPath);
+        var callbacks = LOADED_PLUGINS.get(resolved);
+        if (!callbacks) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                require(resolved);
+            }
+            catch (e) {
+                throw new Error("Failed to load Flamework plugin '".concat(pluginPath, "': ").concat(e instanceof Error ? e.message : e));
+            }
+            callbacks = registry.drainRegisteredPlugins();
+            if (callbacks.length === 0) {
+                throw new Error("Flamework plugin '".concat(pluginPath, "' did not call registerPlugin(). ") +
+                    "Plugins must be CommonJS modules that call registerPlugin at the top level.");
+            }
+            LOADED_PLUGINS.set(resolved, callbacks);
+        }
+        var api = {
+            factory: factory,
+            options: options,
+            registerMacroType: function (id, handler) {
+                var existing = macroTypes.get(id);
+                if (existing) {
+                    throw new Error("Flamework plugin '".concat(pluginPath, "' registered the macro type '").concat(id, "', ") +
+                        "which was already registered by '".concat(existing.pluginName, "'."));
+                }
+                macroTypes.set(id, { handler: handler, pluginName: pluginPath });
+            },
+        };
+        try {
+            for (var callbacks_1 = __values(callbacks), callbacks_1_1 = callbacks_1.next(); !callbacks_1_1.done; callbacks_1_1 = callbacks_1.next()) {
+                var plugin = callbacks_1_1.value;
+                plugin(api);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (callbacks_1_1 && !callbacks_1_1.done && (_a = callbacks_1.return)) _a.call(callbacks_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    function executeMacroType(name, type, node) {
+        var registered = macroTypes.get(name);
+        if (!registered) {
+            return;
+        }
+        var file = state.getSourceFile(node);
+        var cacheKey = "".concat(name, "\0").concat(state.typeChecker.typeToString(type), "\0").concat(getTypeKey(type));
+        // Results are cached per file. Re-emitting a whole object literal at every call site is the
+        // main cost of a macro type, so the second use in a file hoists it into a shared constant.
+        var cached = cache.get(cacheKey);
+        if (cached && cached.fileName === file.fileName) {
+            return cached.expression;
+        }
+        var _a = createMacroContext(file, node), context = _a.context, hoistRaw = _a.hoistRaw;
+        var result = (0, nodeFactory_1.unwrapNode)(registered.handler(types.wrap(type), context));
+        if (!typescript_1.default.isExpression(result)) {
+            diagnostics_1.Diagnostics.error(node, "Flamework plugin macro type '".concat(name, "' returned a non-expression."));
+        }
+        var expression = isTriviallyDuplicable(result) ? result : hoistRaw(result, name);
+        cache.set(cacheKey, { fileName: file.fileName, expression: expression });
+        return expression;
+    }
+    function createMacroContext(file, node) {
+        function hoistRaw(expression, name) {
+            if (name === void 0) { name = "plugin"; }
+            var identifier = factory_1.f.identifier(name, true);
+            state.nextRootStatements.push(factory_1.f.variableStatement(identifier, expression));
+            return identifier;
+        }
+        var context = {
+            hoist: function (expression, name) {
+                var unwrapped = (0, nodeFactory_1.unwrapNode)(expression);
+                if (!typescript_1.default.isExpression(unwrapped)) {
+                    diagnostics_1.Diagnostics.error(node, "hoist was called with a node that is not an expression.");
+                }
+                return (0, nodeFactory_1.createNodeHandle)(hoistRaw(unwrapped, name));
+            },
+            hoistStatement: function (statement) {
+                var unwrapped = (0, nodeFactory_1.unwrapNode)(statement);
+                if (!typescript_1.default.isStatement(unwrapped)) {
+                    diagnostics_1.Diagnostics.error(node, "hoistStatement was called with a node that is not a statement.");
+                }
+                state.nextRootStatements.push(unwrapped);
+            },
+            error: function (message) {
+                return diagnostics_1.Diagnostics.error(node, message);
+            },
+            warning: function (message) {
+                diagnostics_1.Diagnostics.warning(node, message);
+            },
+            fileName: file.fileName,
+        };
+        return { context: context, hoistRaw: hoistRaw };
+    }
+}
+/**
+ * Literals and identifiers are cheap enough to duplicate at each call site, and duplicating them
+ * avoids emitting a constant for something like `"foo"`.
+ */
+function isTriviallyDuplicable(node) {
+    return (typescript_1.default.isStringLiteral(node) ||
+        typescript_1.default.isNumericLiteral(node) ||
+        typescript_1.default.isIdentifier(node) ||
+        node.kind === typescript_1.default.SyntaxKind.TrueKeyword ||
+        node.kind === typescript_1.default.SyntaxKind.FalseKeyword);
+}
+/**
+ * `ts.Type` has a stable numeric id, but it is internal. Falling back to the printed type keeps the
+ * cache correct (never merging distinct types) if the id is unavailable.
+ */
+function getTypeKey(type) {
+    var _a;
+    return (_a = type.id) !== null && _a !== void 0 ? _a : -1;
+}
+function resolvePluginPath(state, pluginPath) {
+    if (pluginPath.startsWith(".")) {
+        return path_1.default.resolve(state.rootDirectory, pluginPath);
+    }
+    try {
+        return require.resolve(pluginPath, { paths: [state.rootDirectory] });
+    }
+    catch (_a) {
+        throw new Error("Could not resolve Flamework plugin '".concat(pluginPath, "' from '").concat(state.rootDirectory, "'. ") +
+            "Use a relative path for local plugins, or install the plugin as a dependency.");
+    }
+}
+function requirePluginRegistry(state) {
+    var resolved;
+    try {
+        resolved = require.resolve(packages_1.PLUGIN_PACKAGE, { paths: [state.rootDirectory] });
+    }
+    catch (_a) {
+        throw new Error("Flamework plugins are configured, but '".concat(packages_1.PLUGIN_PACKAGE, "' is not installed. ") +
+            "Add it as a dev dependency of your project.");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(resolved);
+}

package/out/transformations/plugins/typeFacade.js

@@ -0,0 +1,242 @@
+"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.createTypeFactory = createTypeFactory;
+var typescript_1 = __importDefault(require("typescript"));
+var isTupleType_1 = require("../../util/functions/isTupleType");
+var tsInternals_1 = require("../../util/tsInternals");
+/**
+ * Wraps a `ts.Type` in the stable surface plugins are allowed to see.
+ *
+ * Facades are cached per `ts.Type` so that plugins can use reference equality and so repeated
+ * traversals of the same type do not reallocate.
+ */
+function createTypeFactory(state) {
+    var checker = state.typeChecker;
+    var cache = new Map();
+    function wrap(type) {
+        var existing = cache.get(type);
+        if (existing) {
+            return existing;
+        }
+        var facade = new TypeFacade(type);
+        cache.set(type, facade);
+        return facade;
+    }
+    function unwrap(type) {
+        if (!(type instanceof TypeFacade)) {
+            throw new Error("received a Type that was not created by this transformer");
+        }
+        return type.type;
+    }
+    var TypeFacade = /** @class */ (function () {
+        function TypeFacade(type) {
+            this.type = type;
+        }
+        TypeFacade.prototype.isSubtypeOf = function (other) {
+            return checker.isTypeAssignableTo(this.type, unwrap(other));
+        };
+        TypeFacade.prototype.isSupertypeOf = function (other) {
+            return checker.isTypeAssignableTo(unwrap(other), this.type);
+        };
+        TypeFacade.prototype.isEquivalentTo = function (other) {
+            var otherType = unwrap(other);
+            return checker.isTypeAssignableTo(this.type, otherType) && checker.isTypeAssignableTo(otherType, this.type);
+        };
+        TypeFacade.prototype.isIntersection = function () {
+            return this.type.isIntersection();
+        };
+        TypeFacade.prototype.isUnion = function () {
+            return this.type.isUnion();
+        };
+        TypeFacade.prototype.isObjectLike = function () {
+            return (this.type.flags & typescript_1.default.TypeFlags.Object) !== 0;
+        };
+        TypeFacade.prototype.isArray = function () {
+            return (0, isTupleType_1.isArrayType)(state, this.type) || (0, isTupleType_1.isTupleType)(state, this.type);
+        };
+        TypeFacade.prototype.isTuple = function () {
+            return (0, isTupleType_1.isTupleType)(state, this.type);
+        };
+        TypeFacade.prototype.isLiteral = function (kind) {
+            if (kind === "string")
+                return this.type.isStringLiteral();
+            if (kind === "number")
+                return this.type.isNumberLiteral();
+            if (kind === "boolean")
+                return (this.type.flags & typescript_1.default.TypeFlags.BooleanLiteral) !== 0;
+            return this.type.isLiteral() || (this.type.flags & typescript_1.default.TypeFlags.BooleanLiteral) !== 0;
+        };
+        TypeFacade.prototype.isPrimitive = function (primitive) {
+            if ((this.type.flags & tsInternals_1.TYPE_FLAG_INTRINSIC) === 0) {
+                return false;
+            }
+            return this.type.intrinsicName === primitive;
+        };
+        TypeFacade.prototype.getNonNullable = function () {
+            return wrap(this.type.getNonNullableType());
+        };
+        TypeFacade.prototype.isOptional = function () {
+            if (!this.type.isUnion()) {
+                return false;
+            }
+            return this.type.types.some(function (v) { return (v.flags & (typescript_1.default.TypeFlags.Undefined | typescript_1.default.TypeFlags.Null)) !== 0; });
+        };
+        TypeFacade.prototype.getName = function () {
+            var _a, _b, _c;
+            return (_b = (_a = this.type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = this.type.getSymbol()) === null || _c === void 0 ? void 0 : _c.name;
+        };
+        // UnionOrIntersectionType
+        TypeFacade.prototype.getConstituents = function () {
+            if (!this.type.isUnionOrIntersection()) {
+                throw new Error("getConstituents called on a type that is not a union or intersection");
+            }
+            return this.type.types.map(wrap);
+        };
+        // ObjectLikeType
+        TypeFacade.prototype.getFields = function () {
+            var e_1, _a;
+            var fields = new Array();
+            try {
+                for (var _b = __values(checker.getPropertiesOfType(this.type)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var field = _c.value;
+                    var fieldType = checker.getTypeOfPropertyOfType(this.type, field.name);
+                    if (!fieldType) {
+                        continue;
+                    }
+                    fields.push({
+                        name: field.name,
+                        readonly: isReadonlySymbol(field),
+                        optional: (field.flags & typescript_1.default.SymbolFlags.Optional) !== 0,
+                        type: wrap(fieldType),
+                    });
+                }
+            }
+            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; }
+            }
+            return fields;
+        };
+        TypeFacade.prototype.getIndexSignatures = function () {
+            return checker.getIndexInfosOfType(this.type).map(function (info) { return ({
+                key: wrap(info.keyType),
+                value: wrap(info.type),
+                readonly: info.isReadonly,
+            }); });
+        };
+        TypeFacade.prototype.getCallSignatures = function () {
+            return this.getSignatures(typescript_1.default.SignatureKind.Call);
+        };
+        TypeFacade.prototype.getConstructSignatures = function () {
+            return this.getSignatures(typescript_1.default.SignatureKind.Construct);
+        };
+        TypeFacade.prototype.getSignatures = function (kind) {
+            return checker.getSignaturesOfType(this.type, kind).map(function (signature) { return ({
+                inputs: signature.getParameters().map(function (v) { return wrap(checker.getTypeOfSymbol(v)); }),
+                output: wrap(signature.getReturnType()),
+            }); });
+        };
+        // TupleArrayType
+        TypeFacade.prototype.getElements = function () {
+            if (!(0, isTupleType_1.isTupleType)(state, this.type)) {
+                throw new Error("getElements called on a type that is not a tuple");
+            }
+            var target = this.type.target;
+            return checker.getTypeArguments(this.type).map(function (argument, index) {
+                var _a, _b;
+                var nameDeclaration = (_b = (_a = target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[index]) === null || _b === void 0 ? void 0 : _b.name;
+                var elementFlags = target.elementFlags[index];
+                return {
+                    name: nameDeclaration && typescript_1.default.isIdentifier(nameDeclaration) ? nameDeclaration.text : undefined,
+                    type: wrap(argument),
+                    spread: (elementFlags & typescript_1.default.ElementFlags.Rest) !== 0,
+                    optional: (elementFlags & typescript_1.default.ElementFlags.Optional) !== 0,
+                };
+            });
+        };
+        // ArrayType
+        TypeFacade.prototype.getElementType = function () {
+            var _a;
+            if ((0, isTupleType_1.isTupleType)(state, this.type)) {
+                var elements = checker.getTypeArguments(this.type);
+                return wrap(elements.length > 0 ? checker.getUnionType(__spreadArray([], __read(elements), false)) : checker.getNeverType());
+            }
+            if (!(0, isTupleType_1.isArrayType)(state, this.type)) {
+                throw new Error("getElementType called on a type that is not an array");
+            }
+            return wrap((_a = checker.getElementTypeOfArrayType(this.type)) !== null && _a !== void 0 ? _a : checker.getAnyType());
+        };
+        TypeFacade.prototype.isReadonly = function () {
+            var symbol = this.type.getSymbol();
+            if (!symbol) {
+                return false;
+            }
+            // `readonly T[]` and `ReadonlyArray<T>` both resolve to the global ReadonlyArray symbol.
+            var readonlyArray = checker.resolveName("ReadonlyArray", undefined, typescript_1.default.SymbolFlags.Type, false);
+            return (readonlyArray !== undefined &&
+                checker.getMergedSymbol(symbol) === checker.getMergedSymbol(readonlyArray));
+        };
+        // LiteralType
+        TypeFacade.prototype.getLiteralValue = function () {
+            if (this.type.isStringLiteral() || this.type.isNumberLiteral()) {
+                return this.type.value;
+            }
+            if (this.type === checker.getTrueType())
+                return true;
+            if (this.type === checker.getFalseType())
+                return false;
+            throw new Error("getLiteralValue called on a type that is not a literal");
+        };
+        TypeFacade.prototype.toString = function () {
+            return checker.typeToString(this.type);
+        };
+        return TypeFacade;
+    }());
+    function isReadonlySymbol(symbol) {
+        var _a, _b;
+        return (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(function (v) { return typescript_1.default.isDeclarationReadonly(v); })) !== null && _b !== void 0 ? _b : false;
+    }
+    return { wrap: wrap, unwrap: unwrap };
+}