@spyglassmc/core 0.1.0

package/lib/symbol/SymbolUtil.js

@@ -0,0 +1,880 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SymbolUtil_global, _SymbolUtil_trimmableSymbols, _SymbolUtil_cache, _SymbolUtil_currentContributor, _SymbolQuery_doc, _SymbolQuery_node, _SymbolQuery_createdWithUri, _SymbolQuery_currentContributor, _SymbolQuery_hasTriggeredIf, _SymbolQuery_map, _SymbolQuery_parentSymbol, _SymbolQuery_symbol;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolFormatter = exports.SymbolQuery = exports.SymbolUtil = void 0;
+const assert_1 = require("assert");
+const events_1 = __importDefault(require("events"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const source_1 = require("../source");
+const Symbol_1 = require("./Symbol");
+class SymbolUtil extends events_1.default {
+    constructor(global, 
+    /** @internal */
+    _currentContributor, 
+    /** @internal */
+    _inDelayMode = false) {
+        super();
+        _SymbolUtil_global.set(this, void 0);
+        _SymbolUtil_trimmableSymbols.set(this, new Set());
+        _SymbolUtil_cache.set(this, Object.create(null));
+        _SymbolUtil_currentContributor.set(this, void 0);
+        /**
+         * @internal
+         */
+        this._delayedOps = [];
+        __classPrivateFieldSet(this, _SymbolUtil_global, global, "f");
+        __classPrivateFieldSet(this, _SymbolUtil_currentContributor, _currentContributor, "f");
+        this._inDelayMode = _inDelayMode;
+        this
+            .on('symbolCreated', ({ symbol }) => {
+            __classPrivateFieldGet(this, _SymbolUtil_trimmableSymbols, "f").add(Symbol_1.SymbolPath.toString(symbol));
+        })
+            .on('symbolRemoved', ({ symbol }) => {
+            __classPrivateFieldGet(this, _SymbolUtil_trimmableSymbols, "f").delete(Symbol_1.SymbolPath.toString(symbol));
+        })
+            .on('symbolLocationCreated', ({ symbol, location }) => {
+            var _a, _b, _c;
+            const cache = (_a = __classPrivateFieldGet(this, _SymbolUtil_cache, "f"))[_b = location.contributor ?? 'undefined'] ?? (_a[_b] = Object.create(null));
+            const fileSymbols = cache[_c = location.uri] ?? (cache[_c] = new Set());
+            const path = Symbol_1.SymbolPath.toString(symbol);
+            fileSymbols.add(path);
+            __classPrivateFieldGet(this, _SymbolUtil_trimmableSymbols, "f").delete(path);
+        })
+            .on('symbolLocationRemoved', ({ symbol }) => {
+            const path = Symbol_1.SymbolPath.toString(symbol);
+            __classPrivateFieldGet(this, _SymbolUtil_trimmableSymbols, "f").add(path);
+        });
+    }
+    get global() {
+        return __classPrivateFieldGet(this, _SymbolUtil_global, "f");
+    }
+    /**
+     * Build the internal cache of the SymbolUtil according to the current global symbol table.
+     */
+    buildCache() {
+        SymbolUtil.forEachSymbol(this.global, symbol => {
+            this.emit('symbolCreated', { symbol });
+            SymbolUtil.forEachLocationOfSymbol(symbol, ({ type, location }) => {
+                this.emit('symbolLocationCreated', { symbol, type, location });
+            });
+        });
+    }
+    /**
+     * @returns A clone of this SymbolUtil that is in delay mode: changes to the symbol table happened in the clone will
+     * not take effect until the {@link SymbolUtil.applyDelayedEdits} method is called on that clone.
+     *
+     * The clone shares the same reference of the global symbol table and symbol stacks, meaning that after
+     * `applyDelayedEdits` is called, the original SymbolUtil will also be modified.
+     */
+    clone() {
+        return new SymbolUtil(__classPrivateFieldGet(this, _SymbolUtil_global, "f"), __classPrivateFieldGet(this, _SymbolUtil_currentContributor, "f"), true);
+    }
+    /**
+     * Apply edits done during the delay mode.
+     */
+    applyDelayedEdits() {
+        this._delayedOps.forEach(f => f());
+        this._delayedOps = [];
+        this._inDelayMode = false;
+    }
+    contributeAs(contributor, fn) {
+        const originalValue = __classPrivateFieldGet(this, _SymbolUtil_currentContributor, "f");
+        __classPrivateFieldSet(this, _SymbolUtil_currentContributor, contributor, "f");
+        try {
+            fn();
+        }
+        finally {
+            __classPrivateFieldSet(this, _SymbolUtil_currentContributor, originalValue, "f");
+        }
+        return this;
+    }
+    async contributeAsAsync(contributor, fn) {
+        const originalValue = __classPrivateFieldGet(this, _SymbolUtil_currentContributor, "f");
+        __classPrivateFieldSet(this, _SymbolUtil_currentContributor, contributor, "f");
+        try {
+            await fn();
+        }
+        finally {
+            __classPrivateFieldSet(this, _SymbolUtil_currentContributor, originalValue, "f");
+        }
+        return this;
+    }
+    /**
+     * @param
+     * 	- `contributor` - clear symbol locations contributed by this contributor. Pass in `undefined`
+     * 	to select all symbol locations that don't have a contributor.
+     * 	- `uri` - clear symbol locations associated with this URI.
+     * 	- `predicate` - clear symbol locations matching this predicate
+     */
+    clear({ uri, contributor, predicate = () => true }) {
+        const getCaches = () => {
+            if (contributor) {
+                return __classPrivateFieldGet(this, _SymbolUtil_cache, "f")[contributor] ? [__classPrivateFieldGet(this, _SymbolUtil_cache, "f")[contributor]] : [];
+            }
+            else {
+                return Object.values(__classPrivateFieldGet(this, _SymbolUtil_cache, "f"));
+            }
+        };
+        const getPaths = () => {
+            const caches = getCaches();
+            const sets = uri
+                ? caches.map(cache => cache[uri] ?? new Set())
+                : caches.map(cache => Object.values(cache)).flat();
+            return sets.map(s => [...s]).flat().map(Symbol_1.SymbolPath.fromString);
+        };
+        const getTables = () => {
+            return uri
+                ? [__classPrivateFieldGet(this, _SymbolUtil_global, "f")]
+                : [__classPrivateFieldGet(this, _SymbolUtil_global, "f")];
+        };
+        const paths = getPaths();
+        const tables = getTables();
+        for (const table of tables) {
+            for (const path of paths) {
+                const { symbol } = SymbolUtil.lookupTable(table, path.category, path.path);
+                if (!symbol) {
+                    continue;
+                }
+                this.removeLocationsFromSymbol(symbol, uri
+                    ? data => data.location.uri === uri && predicate(data)
+                    : predicate);
+            }
+            this.trim(table);
+        }
+    }
+    lookup(category, path, node) {
+        return SymbolUtil.lookupTable(this.global, category, path);
+    }
+    query(doc, category, ...path) {
+        const uri = SymbolUtil.toUri(doc);
+        const { parentSymbol, parentMap, symbol } = this.lookup(category, path, isDocAndNode(doc) ? doc.node : undefined);
+        const visible = symbol ? SymbolUtil.isVisible(symbol, uri) : true;
+        return new SymbolQuery({
+            category,
+            doc,
+            contributor: __classPrivateFieldGet(this, _SymbolUtil_currentContributor, "f"),
+            map: visible ? parentMap : undefined,
+            parentSymbol: parentSymbol,
+            path,
+            symbol: visible ? symbol : undefined,
+            util: this,
+        });
+    }
+    getVisibleSymbols(category, uri) {
+        const map = this.lookup(category, [], undefined).parentMap ?? undefined;
+        return SymbolUtil.filterVisibleSymbols(uri, map);
+    }
+    static toUri(uri) {
+        if (typeof uri === 'string') {
+            return uri;
+        }
+        if (isDocAndNode(uri)) {
+            return uri.doc.uri;
+        }
+        return uri.uri;
+    }
+    /**
+     * @see {@link SymbolUtil.trimMap}
+     */
+    trim(table) {
+        const trimSymbol = (symbol) => {
+            if (!symbol) {
+                return;
+            }
+            if (SymbolUtil.isTrimmable(symbol)) {
+                delete symbol.parentMap[symbol.identifier];
+                this.emit('symbolRemoved', { symbol });
+                trimSymbol(symbol.parentSymbol);
+            }
+        };
+        for (const pathString of __classPrivateFieldGet(this, _SymbolUtil_trimmableSymbols, "f")) {
+            const path = Symbol_1.SymbolPath.fromString(pathString);
+            const { symbol } = SymbolUtil.lookupTable(table, path.category, path.path);
+            trimSymbol(symbol);
+        }
+    }
+    removeLocationsFromSymbol(symbol, predicate) {
+        for (const type of Symbol_1.SymbolUsageTypes) {
+            if (!symbol[type]) {
+                continue;
+            }
+            symbol[type] = symbol[type].reduce((result, location) => {
+                if (predicate({ location, symbol, type })) {
+                    this.emit('symbolLocationRemoved', { symbol, type, location });
+                }
+                else {
+                    result.push(location);
+                }
+                return result;
+            }, []);
+        }
+    }
+    enterMap(parentSymbol, map, category, path, identifier, addition, doc, contributor) {
+        let ans = map[identifier];
+        if (ans) {
+            this.amendSymbol(ans, addition, doc, contributor);
+        }
+        else {
+            ans = this.createSymbol(category, parentSymbol, map, path, identifier, addition, doc, contributor);
+        }
+        this.emit('symbolAmended', { symbol: ans });
+        return ans;
+    }
+    static lookupTable(table, category, path) {
+        let parentMap = table[category];
+        let parentSymbol;
+        let symbol;
+        for (let i = 0; i < path.length; i++) {
+            symbol = parentMap?.[path[i]];
+            if (!symbol) {
+                if (i !== path.length - 1) {
+                    parentSymbol = undefined;
+                    parentMap = undefined;
+                }
+                break;
+            }
+            if (i === path.length - 1) {
+                break;
+            }
+            parentSymbol = symbol;
+            parentMap = symbol.members;
+        }
+        return { parentSymbol, parentMap, symbol };
+    }
+    static lookupTables(tables, category, path) {
+        let parentMap;
+        let parentSymbol;
+        // Traverse from the last table to the first one.
+        for (let i = tables.length - 1; i >= 0; i--) {
+            const table = tables[i];
+            const result = this.lookupTable(table, category, path);
+            if (result.symbol) {
+                return result;
+            }
+            if (!parentSymbol && !parentMap && (result.parentSymbol || result.parentMap)) {
+                parentSymbol = result.parentSymbol;
+                parentMap = result.parentMap;
+            }
+        }
+        return { parentSymbol, parentMap, symbol: undefined };
+    }
+    createSymbol(category, parentSymbol, parentMap, path, identifier, addition, doc, contributor) {
+        const ans = parentMap[identifier] = {
+            category,
+            identifier,
+            ...parentSymbol ? { parentSymbol } : {},
+            parentMap,
+            path,
+            ...addition.data,
+        };
+        this.emit('symbolCreated', { symbol: ans });
+        this.amendSymbolUsage(ans, addition.usage, doc, contributor);
+        return ans;
+    }
+    amendSymbol(symbol, addition, doc, contributor) {
+        this.amendSymbolMetadata(symbol, addition.data);
+        this.amendSymbolUsage(symbol, addition.usage, doc, contributor);
+    }
+    amendSymbolMetadata(symbol, addition) {
+        if (addition) {
+            if ('data' in addition) {
+                symbol.data = addition.data;
+            }
+            if ('desc' in addition) {
+                symbol.desc = addition.desc;
+            }
+            if (addition.relations && Object.keys(addition.relations).length) {
+                symbol.relations ?? (symbol.relations = {});
+                for (const relationship of Object.keys(addition.relations)) {
+                    symbol.relations[relationship] = addition.relations[relationship];
+                }
+            }
+            if ('subcategory' in addition) {
+                symbol.subcategory = addition.subcategory;
+            }
+            if ('visibility' in addition) {
+                // Visibility changes are only accepted if the change wouldn't result in the
+                // symbol being stored in a different symbol table.
+                const inGlobalTable = (v) => v === undefined || v === 2 /* Public */ || v === 3 /* Restricted */;
+                if (symbol.visibility === addition.visibility || (inGlobalTable(symbol.visibility) && inGlobalTable(addition.visibility))) {
+                    symbol.visibility = addition.visibility;
+                }
+                else {
+                    throw new Error(`Cannot change visibility from ${symbol.visibility} to ${addition.visibility}: ${JSON.stringify(Symbol_1.SymbolPath.fromSymbol(symbol))}`);
+                }
+            }
+            if (addition.visibilityRestriction?.length) {
+                symbol.visibilityRestriction = (symbol.visibilityRestriction ?? []).concat(addition.visibilityRestriction);
+            }
+        }
+    }
+    amendSymbolUsage(symbol, addition, doc, contributor) {
+        if (addition) {
+            const type = addition.type ?? 'reference';
+            const arr = symbol[type] ?? (symbol[type] = []);
+            const range = source_1.Range.get((SymbolAdditionUsageWithNode.is(addition) ? addition.node : addition.range) ?? 0);
+            const location = Symbol_1.SymbolLocation.create(doc, range, addition.fullRange, contributor, {
+                accessType: addition.accessType,
+                skipRenaming: addition.skipRenaming,
+            });
+            if (!doc.uri.startsWith('file:')) {
+                delete location.range;
+                delete location.posRange;
+                delete location.fullRange;
+                delete location.fullPosRange;
+            }
+            arr.push(location);
+            this.emit('symbolLocationCreated', { symbol, type, location });
+        }
+    }
+    /**
+     * @returns The ultimate symbol being pointed by the passed-in `symbol`'s alias.
+     */
+    resolveAlias(symbol) {
+        return symbol?.relations?.aliasOf
+            ? this.resolveAlias(this.lookup(symbol.relations.aliasOf.category, symbol.relations.aliasOf.path).symbol)
+            : symbol;
+    }
+    static filterVisibleSymbols(uri, map = {}) {
+        const ans = {};
+        for (const [identifier, symbol] of Object.entries(map)) {
+            if (SymbolUtil.isVisible(symbol, uri)) {
+                ans[identifier] = symbol;
+            }
+        }
+        return ans;
+    }
+    static isTrimmable(symbol) {
+        return !Object.keys(symbol.members ?? {}).length && !symbol.declaration?.length && !symbol.definition?.length && !symbol.implementation?.length && !symbol.reference?.length && !symbol.typeDefinition?.length;
+    }
+    static isVisible(symbol, _uri) {
+        switch (symbol.visibility) {
+            case 3 /* Restricted */:
+                return false; // FIXME: check with workspace root URIs.
+            case 0 /* Block */:
+            case 1 /* File */:
+            case 2 /* Public */:
+            default:
+                return true;
+        }
+    }
+    /**
+     * @returns If the symbol has declarations or definitions.
+     */
+    static isDeclared(symbol) {
+        return !!(symbol?.declaration?.length || symbol?.definition?.length);
+    }
+    /**
+     * @returns If the symbol has definitions, or declarations and implementations.
+     */
+    static isDefined(symbol) {
+        return !!(symbol?.definition?.length || (symbol?.definition?.length && symbol?.implementation?.length));
+    }
+    /**
+     * @returns If the symbol has implementations or definitions.
+     */
+    static isImplemented(symbol) {
+        return !!(symbol?.implementation?.length || symbol?.definition?.length);
+    }
+    /**
+     * @returns If the symbol has references.
+     */
+    static isReferenced(symbol) {
+        return !!symbol?.reference?.length;
+    }
+    /**
+     * @returns If the symbol has type definitions.
+     */
+    static isTypeDefined(symbol) {
+        return !!symbol?.typeDefinition?.length;
+    }
+    /**
+     * @throws If the symbol does not have any declarations or definitions.
+     */
+    static getDeclaredLocation(symbol) {
+        return symbol.declaration?.[0] ?? symbol.definition?.[0] ?? (() => { throw new Error(`Cannot get declared location of ${JSON.stringify(Symbol_1.SymbolPath.fromSymbol(symbol))}`); })();
+    }
+    static forEachSymbolInMap(map, fn) {
+        for (const symbol of Object.values(map)) {
+            fn(symbol);
+            if (symbol.members) {
+                this.forEachSymbolInMap(symbol.members, fn);
+            }
+        }
+    }
+    static forEachSymbol(table, fn) {
+        for (const map of Object.values(table)) {
+            this.forEachSymbolInMap(map, fn);
+        }
+    }
+    static forEachLocationOfSymbol(symbol, fn) {
+        for (const type of Symbol_1.SymbolUsageTypes) {
+            symbol[type]?.forEach(location => fn({ type, location }));
+        }
+    }
+    static isVisibilityInGlobal(v) {
+        return v === undefined || v === 2 /* Public */ || v === 3 /* Restricted */;
+    }
+    static areVisibilitiesCompatible(v1, v2) {
+        return ((this.isVisibilityInGlobal(v1) && this.isVisibilityInGlobal(v2)) ||
+            (v1 === 0 /* Block */ && v2 === 0 /* Block */) ||
+            (v1 === 1 /* File */ && v2 === 1 /* File */));
+    }
+}
+_SymbolUtil_global = new WeakMap(), _SymbolUtil_trimmableSymbols = new WeakMap(), _SymbolUtil_cache = new WeakMap(), _SymbolUtil_currentContributor = new WeakMap();
+__decorate([
+    DelayModeSupport()
+], SymbolUtil.prototype, "clear", null);
+__decorate([
+    DelayModeSupport()
+], SymbolUtil.prototype, "trim", null);
+__decorate([
+    DelayModeSupport()
+], SymbolUtil.prototype, "removeLocationsFromSymbol", null);
+exports.SymbolUtil = SymbolUtil;
+var SymbolAdditionUsageWithRange;
+(function (SymbolAdditionUsageWithRange) {
+    /* istanbul ignore next */
+    function is(usage) {
+        return !!usage?.range;
+    }
+    SymbolAdditionUsageWithRange.is = is;
+})(SymbolAdditionUsageWithRange || (SymbolAdditionUsageWithRange = {}));
+var SymbolAdditionUsageWithNode;
+(function (SymbolAdditionUsageWithNode) {
+    /* istanbul ignore next */
+    function is(usage) {
+        return !!usage?.node;
+    }
+    SymbolAdditionUsageWithNode.is = is;
+})(SymbolAdditionUsageWithNode || (SymbolAdditionUsageWithNode = {}));
+/* istanbul ignore next */
+class SymbolQuery {
+    constructor({ category, contributor, doc, map, parentSymbol, path, symbol, util }) {
+        _SymbolQuery_doc.set(this, void 0);
+        _SymbolQuery_node.set(this, void 0);
+        /**
+         * If only a string URI (instead of a {@link TextDocument}) is provided when constructing this class.
+         *
+         * If this is `true`, {@link SymbolAdditionUsageWithRange.range} is ignored and treated as `[0, 0)` when entering symbols through this class.
+         */
+        _SymbolQuery_createdWithUri.set(this, void 0);
+        _SymbolQuery_currentContributor.set(this, void 0);
+        _SymbolQuery_hasTriggeredIf.set(this, false
+        /**
+         * The map where the queried symbol is stored. `undefined` if the map hasn't been created yet.
+         */
+        );
+        /**
+         * The map where the queried symbol is stored. `undefined` if the map hasn't been created yet.
+         */
+        _SymbolQuery_map.set(this, void 0);
+        _SymbolQuery_parentSymbol.set(this, void 0);
+        /**
+         * The queried symbol. `undefined` if the symbol hasn't been created yet.
+         */
+        _SymbolQuery_symbol.set(this, void 0);
+        this.category = category;
+        this.path = path;
+        if (typeof doc === 'string') {
+            doc = vscode_languageserver_textdocument_1.TextDocument.create(doc, '', 0, '');
+            __classPrivateFieldSet(this, _SymbolQuery_createdWithUri, true, "f");
+        }
+        else if (isDocAndNode(doc)) {
+            __classPrivateFieldSet(this, _SymbolQuery_node, doc.node, "f");
+            doc = doc.doc;
+        }
+        __classPrivateFieldSet(this, _SymbolQuery_doc, doc, "f");
+        __classPrivateFieldSet(this, _SymbolQuery_currentContributor, contributor, "f");
+        __classPrivateFieldSet(this, _SymbolQuery_map, map, "f");
+        __classPrivateFieldSet(this, _SymbolQuery_parentSymbol, parentSymbol, "f");
+        __classPrivateFieldSet(this, _SymbolQuery_symbol, symbol, "f");
+        this.util = util;
+    }
+    get symbol() {
+        return __classPrivateFieldGet(this, _SymbolQuery_symbol, "f");
+    }
+    get visibleMembers() {
+        return SymbolUtil.filterVisibleSymbols(__classPrivateFieldGet(this, _SymbolQuery_doc, "f").uri, this.path.length === 0 ? __classPrivateFieldGet(this, _SymbolQuery_map, "f") : __classPrivateFieldGet(this, _SymbolQuery_symbol, "f")?.members);
+    }
+    heyGimmeDaSymbol() {
+        return __classPrivateFieldGet(this, _SymbolQuery_symbol, "f");
+    }
+    with(fn) {
+        fn(this);
+        return this;
+    }
+    if(predicate, fn) {
+        if (predicate.call(this, __classPrivateFieldGet(this, _SymbolQuery_symbol, "f"), this)) {
+            fn.call(this, __classPrivateFieldGet(this, _SymbolQuery_symbol, "f"), this);
+            __classPrivateFieldSet(this, _SymbolQuery_hasTriggeredIf, true, "f");
+        }
+        return this;
+    }
+    /**
+     * Calls `fn` if the queried symbol does not exist.
+     */
+    ifUnknown(fn) {
+        return this.if(s => s === undefined, fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol exists (i.e. has any of declarations/definitions/implementations/references/typeDefinitions).
+     */
+    ifKnown(fn) {
+        return this.if(s => s !== undefined, fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol has declarations or definitions.
+     */
+    ifDeclared(fn) {
+        return this.if((s) => SymbolUtil.isDeclared(s), fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol has definitions, or both declarations and implementations.
+     */
+    ifDefined(fn) {
+        return this.if(SymbolUtil.isDefined, fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol has implementations or definitions.
+     */
+    ifImplemented(fn) {
+        return this.if(SymbolUtil.isImplemented, fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol has references.
+     */
+    ifReferenced(fn) {
+        return this.if(SymbolUtil.isReferenced, fn);
+    }
+    /**
+     * Calls `fn` if the queried symbol has type definitions.
+     */
+    ifTypeDefined(fn) {
+        return this.if(SymbolUtil.isTypeDefined, fn);
+    }
+    /**
+     * Calls `fn` if none of the former `if` conditions are met.
+     */
+    else(fn) {
+        if (!__classPrivateFieldGet(this, _SymbolQuery_hasTriggeredIf, "f")) {
+            fn.call(this, __classPrivateFieldGet(this, _SymbolQuery_symbol, "f"), this);
+        }
+        return this;
+    }
+    /**
+     * Enters the queried symbol if none of the former `if` conditions are met.
+     */
+    elseEnter(symbol) {
+        return this.else(() => this.enter(symbol));
+    }
+    /**
+     * Resolves the queried symbol if it is an alias and if none of the former `if` conditions are met.
+     *
+     * @throws If the current symbol points to an non-existent symbol.
+     */
+    elseResolveAlias() {
+        return this.else(() => this.resolveAlias());
+    }
+    _enter(addition) {
+        const getMap = (addition) => {
+            var _a, _b;
+            if (__classPrivateFieldGet(this, _SymbolQuery_map, "f") && SymbolUtil.areVisibilitiesCompatible(addition.data?.visibility, __classPrivateFieldGet(this, _SymbolQuery_symbol, "f")?.visibility)) {
+                return __classPrivateFieldGet(this, _SymbolQuery_map, "f");
+            }
+            if (this.path.length > 1) {
+                if (__classPrivateFieldGet(this, _SymbolQuery_parentSymbol, "f")) {
+                    if (!SymbolUtil.areVisibilitiesCompatible(addition.data?.visibility, __classPrivateFieldGet(this, _SymbolQuery_parentSymbol, "f").visibility)) {
+                        throw new Error(`Cannot enter member “${this.getPath()}” of ${SymbolFormatter.stringifyVisibility(addition.data?.visibility)} visibility to parent of ${SymbolFormatter.stringifyVisibility(__classPrivateFieldGet(this, _SymbolQuery_parentSymbol, "f").visibility)} visibility`);
+                    }
+                    return (_a = __classPrivateFieldGet(this, _SymbolQuery_parentSymbol, "f")).members ?? (_a.members = {});
+                }
+            }
+            else {
+                let table;
+                if (SymbolUtil.isVisibilityInGlobal(addition.data?.visibility)) {
+                    table = this.util.global;
+                }
+                else if (addition.data?.visibility === 1 /* File */) {
+                    if (!__classPrivateFieldGet(this, _SymbolQuery_node, "f")) {
+                        throw new Error(`Cannot enter “${this.getPath()}” with ${SymbolFormatter.stringifyVisibility(addition.data?.visibility)} visibility as no node is supplied`);
+                    }
+                    let node = __classPrivateFieldGet(this, _SymbolQuery_node, "f");
+                    while (node) {
+                        if (node.type === 'file') {
+                            table = node.locals;
+                            break;
+                        }
+                        node = node.parent;
+                    }
+                    if (!table) {
+                        throw new Error(`Cannot enter “${this.getPath()}” with ${SymbolFormatter.stringifyVisibility(addition.data?.visibility)} visibility as no file node is supplied`);
+                    }
+                }
+                else {
+                    if (!__classPrivateFieldGet(this, _SymbolQuery_node, "f")) {
+                        throw new Error(`Cannot enter “${this.getPath()}” with ${SymbolFormatter.stringifyVisibility(addition.data?.visibility)} visibility as no node is supplied`);
+                    }
+                    let node = __classPrivateFieldGet(this, _SymbolQuery_node, "f");
+                    while (node) {
+                        if (node.locals) {
+                            table = node.locals;
+                            break;
+                        }
+                        node = node.parent;
+                    }
+                    if (!table) {
+                        throw new Error(`Cannot enter “${this.getPath()}” with ${SymbolFormatter.stringifyVisibility(addition.data?.visibility)} visibility as no node with locals is supplied`);
+                    }
+                }
+                // TODO: Move part of symbol from global to table.
+                return table[_b = this.category] ?? (table[_b] = {});
+            }
+            throw new Error(`Cannot create the symbol map for “${this.getPath()}”`);
+        };
+        // Treat `usage.range` as `[0, 0)` if this class was constructed with a string URI (instead of a `TextDocument`).
+        if (__classPrivateFieldGet(this, _SymbolQuery_createdWithUri, "f") && SymbolAdditionUsageWithRange.is(addition.usage)) {
+            addition.usage.range = source_1.Range.create(0, 0);
+        }
+        __classPrivateFieldSet(this, _SymbolQuery_map, getMap(addition), "f");
+        __classPrivateFieldSet(this, _SymbolQuery_symbol, this.util.enterMap(__classPrivateFieldGet(this, _SymbolQuery_parentSymbol, "f"), __classPrivateFieldGet(this, _SymbolQuery_map, "f"), this.category, this.path, this.path[this.path.length - 1], addition, __classPrivateFieldGet(this, _SymbolQuery_doc, "f"), __classPrivateFieldGet(this, _SymbolQuery_currentContributor, "f")), "f");
+        if (addition.usage?.node) {
+            addition.usage.node.symbol = __classPrivateFieldGet(this, _SymbolQuery_symbol, "f");
+        }
+    }
+    /**
+     * Enters the queried symbol.
+     *
+     * @throws If the parent of this symbol doesn't exist either.
+     */
+    enter(addition) {
+        this._enter(addition);
+        return this;
+    }
+    /**
+     * Amends the queried symbol if the queried symbol exists (i.e. has any of declarations/definitions/implementations/references/typeDefinitions) and is visible at the current scope.
+     *
+     * This is equivalent to calling
+     * ```typescript
+     * query.ifKnown(function () {
+     * 	this.enter(symbol)
+     * })
+     * ```
+     *
+     * Therefore, if the symbol is successfully amended, `elseX` methods afterwards will **not** be executed.
+     */
+    amend(symbol) {
+        return this.ifKnown(() => this.enter(symbol));
+    }
+    /**
+     * Resolves this symbol if it exists and is an alias.
+     *
+     * @throws If the current symbol points to an non-existent symbol. The state of this object will not be changed
+     * after the error is thrown.
+     */
+    resolveAlias() {
+        if (__classPrivateFieldGet(this, _SymbolQuery_symbol, "f")) {
+            const result = this.util.resolveAlias(__classPrivateFieldGet(this, _SymbolQuery_symbol, "f"));
+            if (!result) {
+                throw new Error('The current symbol points to an non-existent symbol.');
+            }
+            __classPrivateFieldSet(this, _SymbolQuery_symbol, result, "f");
+            __classPrivateFieldSet(this, _SymbolQuery_map, result.parentMap, "f");
+        }
+        return this;
+    }
+    member() {
+        // Handle overloads.
+        let doc, identifier, fn;
+        if (arguments.length === 2) {
+            // Ensure the member query result will not unknowingly have a dummy TextDocument passed down from this class.
+            doc = __classPrivateFieldGet(this, _SymbolQuery_createdWithUri, "f") ? __classPrivateFieldGet(this, _SymbolQuery_doc, "f").uri : __classPrivateFieldGet(this, _SymbolQuery_doc, "f");
+            identifier = arguments[0];
+            fn = arguments[1];
+        }
+        else {
+            doc = arguments[0];
+            identifier = arguments[1];
+            fn = arguments[2];
+        }
+        if (__classPrivateFieldGet(this, _SymbolQuery_symbol, "f") === undefined) {
+            throw new Error(`Tried to query member symbol “${identifier}” from an undefined symbol (path “${this.path.join('.')}”)`);
+        }
+        const memberDoc = typeof doc === 'string' && doc === __classPrivateFieldGet(this, _SymbolQuery_doc, "f").uri && !__classPrivateFieldGet(this, _SymbolQuery_createdWithUri, "f")
+            ? __classPrivateFieldGet(this, _SymbolQuery_doc, "f")
+            : doc;
+        const memberMap = __classPrivateFieldGet(this, _SymbolQuery_symbol, "f").members;
+        const memberSymbol = memberMap?.[identifier];
+        const memberQueryResult = new SymbolQuery({
+            category: this.category,
+            doc: memberDoc,
+            contributor: __classPrivateFieldGet(this, _SymbolQuery_currentContributor, "f"),
+            map: memberMap,
+            parentSymbol: __classPrivateFieldGet(this, _SymbolQuery_symbol, "f"),
+            path: [...this.path, identifier],
+            symbol: memberSymbol,
+            util: this.util,
+        });
+        fn(memberQueryResult);
+        return this;
+    }
+    /**
+     * Do something with this query on each value in a given iterable. The query itself will be included
+     * in the callback function as the second parameter.
+     */
+    onEach(values, fn) {
+        for (const value of values) {
+            fn.call(this, value, this);
+        }
+        return this;
+    }
+    forEachMember(fn) {
+        return this.onEach(Object.keys(this.visibleMembers), identifier => this.member(identifier, query => fn(identifier, query)));
+    }
+    getPath() {
+        return `${this.category}.${this.path.join('/')}`;
+    }
+}
+_SymbolQuery_doc = new WeakMap(), _SymbolQuery_node = new WeakMap(), _SymbolQuery_createdWithUri = new WeakMap(), _SymbolQuery_currentContributor = new WeakMap(), _SymbolQuery_hasTriggeredIf = new WeakMap(), _SymbolQuery_map = new WeakMap(), _SymbolQuery_parentSymbol = new WeakMap(), _SymbolQuery_symbol = new WeakMap();
+__decorate([
+    DelayModeSupport((self) => self.util)
+], SymbolQuery.prototype, "_enter", null);
+exports.SymbolQuery = SymbolQuery;
+/* istanbul ignore next */
+/**
+ * A series of methods for converting symbol structures to human-readable outputs. Mostly for debug purposes.
+ */
+var SymbolFormatter;
+(function (SymbolFormatter) {
+    const IndentChar = '+ ';
+    function stringifySymbolStack(stack) {
+        return stack.map(table => stringifySymbolTable(table)).join('\n------------\n');
+    }
+    SymbolFormatter.stringifySymbolStack = stringifySymbolStack;
+    function stringifySymbolTable(table, indent = '') {
+        const ans = [];
+        for (const category of Object.keys(table)) {
+            const map = table[category];
+            ans.push([category, stringifySymbolMap(map, `${indent}${IndentChar}`)]);
+        }
+        return ans.map(v => `CATEGORY ${v[0]}\n${v[1]}`).join(`\n${indent}------------\n`) || 'EMPTY TABLE';
+    }
+    SymbolFormatter.stringifySymbolTable = stringifySymbolTable;
+    function stringifySymbolMap(map, indent = '') {
+        if (!map) {
+            return 'undefined';
+        }
+        const ans = [];
+        for (const identifier of Object.keys(map)) {
+            const symbol = map[identifier];
+            assert_1.strict.equal(identifier, symbol.identifier);
+            ans.push(stringifySymbol(symbol, indent));
+        }
+        return ans.join(`\n${indent}------------\n`);
+    }
+    SymbolFormatter.stringifySymbolMap = stringifySymbolMap;
+    function stringifySymbol(symbol, indent = '') {
+        if (!symbol) {
+            return 'undefined';
+        }
+        const ans = [];
+        assert_1.strict.equal(symbol.path[symbol.path.length - 1], symbol.identifier);
+        ans.push(`SYMBOL ${symbol.path.join('.')}` +
+            ` {${symbol.category}${symbol.subcategory ? ` (${symbol.subcategory})` : ''}}` +
+            ` [${stringifyVisibility(symbol.visibility, symbol.visibilityRestriction)}]`);
+        if (symbol.data) {
+            ans.push(`${IndentChar}data: ${JSON.stringify(symbol.data)}`);
+        }
+        if (symbol.desc) {
+            ans.push(`${IndentChar}description: ${symbol.desc}`);
+        }
+        for (const type of Symbol_1.SymbolUsageTypes) {
+            if (symbol[type]) {
+                ans.push(`${IndentChar}${type}:\n${symbol[type].map(v => `${indent}${IndentChar.repeat(2)}${JSON.stringify(v)}`).join(`\n${indent}${IndentChar.repeat(2)}------------\n`)}`);
+            }
+        }
+        if (symbol.relations) {
+            ans.push(`${IndentChar}relations: ${JSON.stringify(symbol.relations)}`);
+        }
+        if (symbol.members) {
+            ans.push(`${IndentChar}members:\n${stringifySymbolMap(symbol.members, `${indent}${IndentChar.repeat(2)}`)}`);
+        }
+        return ans.map(v => `${indent}${v}`).join('\n');
+    }
+    SymbolFormatter.stringifySymbol = stringifySymbol;
+    function stringifyVisibility(visibility, visibilityRestriction) {
+        let stringVisibility;
+        // Const enums cannot be indexed even if `--preserveConstEnums` is on: https://github.com/microsoft/TypeScript/issues/31353
+        switch (visibility) {
+            case 0 /* Block */:
+                stringVisibility = 'Block';
+                break;
+            case 1 /* File */:
+                stringVisibility = 'File';
+                break;
+            case 3 /* Restricted */:
+                stringVisibility = 'Restricted';
+                break;
+            default:
+                stringVisibility = 'Public';
+                break;
+        }
+        return `${stringVisibility}${visibilityRestriction ? ` ${visibilityRestriction.map(v => `“${v}”`).join(', ')}` : ''}`;
+    }
+    SymbolFormatter.stringifyVisibility = stringifyVisibility;
+    function stringifyLookupResult(result) {
+        return `parentSymbol:
+${stringifySymbol(result.parentSymbol, IndentChar)}
+parentMap:
+${stringifySymbolMap(result.parentMap, IndentChar)}
+symbol:
+${stringifySymbol(result.symbol, IndentChar)}`;
+    }
+    SymbolFormatter.stringifyLookupResult = stringifyLookupResult;
+})(SymbolFormatter = exports.SymbolFormatter || (exports.SymbolFormatter = {}));
+/**
+ * Make a method support delay mode: if the {@link SymbolUtil} is in delay mode, the actual invocation of the method will be
+ * stored to the {@link SymbolUtil._delayedOps} array.
+ *
+ * The decorated method MUST have return type `void`.
+ */
+function DelayModeSupport(getUtil = self => self) {
+    return (_target, _key, descripter) => {
+        const decoratedMethod = descripter.value;
+        // The `function` syntax is used to preserve `this` context from the decorated method.
+        descripter.value = function (...args) {
+            const util = getUtil(this);
+            if (util._inDelayMode) {
+                util._delayedOps.push(decoratedMethod.bind(this, ...args));
+            }
+            else {
+                decoratedMethod.apply(this, args);
+            }
+        };
+        return descripter;
+    };
+}
+function isDocAndNode(doc) {
+    return !!doc.doc;
+}
+//# sourceMappingURL=SymbolUtil.js.map