@microsoft/powerquery-language-services 0.3.40 → 0.5.1

package/lib/powerquery-language-services/analysis/analysisBase.js

@@ -12,145 +12,237 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalysisBase = void 0;
+const PQP = require("@microsoft/powerquery-parser/lib/powerquery-parser");
 const powerquery_parser_1 = require("@microsoft/powerquery-parser");
-const InspectionUtils = require("../inspectionUtils");
-const PositionUtils = require("../positionUtils");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
 const inspection_1 = require("../inspection");
 const __1 = require("..");
-const commonTypes_1 = require("../commonTypes");
 const scopeUtils_1 = require("../inspection/scope/scopeUtils");
 const providers_1 = require("../providers");
+// Implementation of Analysis, subclass it as needed.
+// Does not implement `dispose`.
 class AnalysisBase {
-    constructor(uri, analysisSettings, promiseMaybeInspected) {
-        this.uri = uri;
+    constructor(textDocument, analysisSettings) {
+        this.textDocument = textDocument;
         this.analysisSettings = analysisSettings;
-        this.promiseMaybeInspected = promiseMaybeInspected;
-        const library = analysisSettings.library;
-        this.languageAutocompleteItemProvider =
-            analysisSettings.maybeCreateLanguageAutocompleteItemProviderFn !== undefined
-                ? analysisSettings.maybeCreateLanguageAutocompleteItemProviderFn()
-                : new providers_1.LanguageAutocompleteItemProvider(promiseMaybeInspected);
-        this.librarySymbolProvider =
-            analysisSettings.maybeCreateLibrarySymbolProviderFn !== undefined
-                ? analysisSettings.maybeCreateLibrarySymbolProviderFn(library)
-                : new providers_1.LibrarySymbolProvider(library);
-        this.localDocumentProvider =
-            analysisSettings.maybeCreateLocalDocumentProviderFn !== undefined
-                ? analysisSettings.maybeCreateLocalDocumentProviderFn(library, uri, promiseMaybeInspected, analysisSettings.createInspectionSettingsFn)
-                : new providers_1.LocalDocumentProvider(library, uri, promiseMaybeInspected, analysisSettings.createInspectionSettingsFn);
+        this.cancellableTokensByAction = new Map();
+        // Shared across actions
+        this.parseError = undefined;
+        this.parseState = undefined;
+        this.triedLexParse = undefined;
+        this.typeCache = {
+            scopeById: new Map(),
+            typeById: new Map(),
+        };
+        this.languageAutocompleteItemProvider = analysisSettings.languageAutocompleteItemProviderFactory
+            ? analysisSettings.languageAutocompleteItemProviderFactory(analysisSettings.inspectionSettings.locale)
+            : new providers_1.LanguageAutocompleteItemProvider(analysisSettings.inspectionSettings.locale);
+        this.libraryProvider = analysisSettings.libraryProviderFactory
+            ? analysisSettings.libraryProviderFactory(analysisSettings.inspectionSettings.library, analysisSettings.inspectionSettings.locale)
+            : new providers_1.LibraryProvider(analysisSettings.inspectionSettings.library, analysisSettings.inspectionSettings.locale);
+        this.localDocumentProvider = analysisSettings.localDocumentProviderFactory
+            ? analysisSettings.localDocumentProviderFactory(textDocument.uri.toString(), this.typeCache, analysisSettings.inspectionSettings.library, analysisSettings.inspectionSettings.locale)
+            : new providers_1.LocalDocumentProvider(this.textDocument.uri.toString(), this.typeCache, analysisSettings.inspectionSettings.library, analysisSettings.inspectionSettings.locale);
+        void this.initializeState();
     }
-    getAutocompleteItems() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getAutocompleteItems.name, this.analysisSettings.maybeInitialCorrelationId);
-            let context = {
-                traceManager: this.analysisSettings.traceManager,
-                maybeInitialCorrelationId: trace.id,
-            };
-            const maybeActiveLeafIdentifier = yield this.getActiveLeafIdentifier();
-            if (maybeActiveLeafIdentifier !== undefined) {
-                context = Object.assign(Object.assign({}, context), { range: __1.CommonTypesUtils.rangeFromTokenRange(maybeActiveLeafIdentifier.node.tokenRange), text: maybeActiveLeafIdentifier.normalizedLiteral, tokenKind: maybeActiveLeafIdentifier.node.kind });
+    getAutocompleteItems(position, cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getAutocompleteItems.name, this.analysisSettings.initialCorrelationId);
+            const context = yield this.getAutocompleteItemProviderContext(position, trace.id, cancellationToken);
+            if (context === undefined) {
+                trace.exit();
+                return undefined;
             }
+            const autocompleteItemTasks = [
+                this.languageAutocompleteItemProvider.getAutocompleteItems(context),
+                this.libraryProvider.getAutocompleteItems(context),
+                this.localDocumentProvider.getAutocompleteItems(context),
+            ];
+            const autocompleteItems = [];
             // TODO: intellisense improvements
             // - honor expected data type
-            // - only include current query name after @
-            const [languageResponse, libraryResponse, localDocumentResponse] = yield Promise.all(AnalysisBase.createAutocompleteItemCalls(context, [this.languageAutocompleteItemProvider, this.librarySymbolProvider, this.localDocumentProvider], this.analysisSettings.symbolProviderTimeoutInMS));
-            const partial = [];
-            for (const collection of [localDocumentResponse, languageResponse, libraryResponse]) {
-                for (const item of collection) {
-                    if (partial.find((partialItem) => partialItem.label === item.label) === undefined) {
-                        partial.push(item);
+            for (const result of yield Promise.all(autocompleteItemTasks)) {
+                if (powerquery_parser_1.ResultUtils.isOk(result) && result.value !== undefined) {
+                    for (const item of result.value) {
+                        autocompleteItems.push(item);
                     }
                 }
             }
-            const result = partial.sort(inspection_1.AutocompleteItemUtils.compareFn);
             trace.exit();
-            return result;
-        });
+            return autocompleteItems;
+        }), this.analysisSettings.inspectionSettings.locale);
     }
-    getDefinition() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinition.name, this.analysisSettings.maybeInitialCorrelationId);
-            const maybeIdentifierContext = yield this.getOnIdentifierProviderContext(trace.id);
-            if (!maybeIdentifierContext) {
+    getDefinition(position, cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinition.name, this.analysisSettings.initialCorrelationId);
+            const identifierContext = yield this.getDefinitionProviderContext(position, trace.id, cancellationToken);
+            if (!identifierContext) {
                 trace.exit();
-                return [];
+                return undefined;
             }
-            const result = yield this.localDocumentProvider.getDefinition(maybeIdentifierContext);
+            const result = yield this.localDocumentProvider.getDefinition(identifierContext);
             trace.exit();
-            return result !== null && result !== void 0 ? result : [];
-        });
+            if (powerquery_parser_1.ResultUtils.isError(result)) {
+                throw result.error;
+            }
+            return result.value;
+        }), this.analysisSettings.inspectionSettings.locale);
     }
-    getHover() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getHover.name, this.analysisSettings.maybeInitialCorrelationId);
-            const maybeIdentifierContext = yield this.getOnIdentifierProviderContext(trace.id);
-            if (!maybeIdentifierContext) {
+    getDocumentSymbols(cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseState();
+            if (parseState === undefined) {
+                return undefined;
+            }
+            const nodeIdMapCollection = parseState.contextState.nodeIdMapCollection;
+            const currentSymbols = [];
+            const parentSymbolById = new Map();
+            addIdentifierPairedExpressionSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken);
+            addRecordSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken);
+            return currentSymbols;
+        }), this.analysisSettings.inspectionSettings.locale);
+    }
+    getFoldingRanges(cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getFoldingRanges.name, this.analysisSettings.initialCorrelationId);
+            const parseState = yield this.getParseState();
+            if (parseState === undefined) {
                 trace.exit();
-                return commonTypes_1.EmptyHover;
+                return undefined;
             }
-            // Result priority is based on the order of the symbol providers
-            const result = AnalysisBase.resolveProviders(AnalysisBase.createHoverCalls(maybeIdentifierContext, [this.localDocumentProvider, this.librarySymbolProvider], this.analysisSettings.symbolProviderTimeoutInMS), commonTypes_1.EmptyHover);
+            const result = yield this.localDocumentProvider.getFoldingRanges({
+                traceManager: this.analysisSettings.traceManager,
+                initialCorrelationId: trace.id,
+                cancellationToken,
+                nodeIdMapCollection: parseState.contextState.nodeIdMapCollection,
+            });
             trace.exit();
-            return result;
+            if (powerquery_parser_1.ResultUtils.isError(result)) {
+                throw result.error;
+            }
+            return result.value;
+        }), this.analysisSettings.inspectionSettings.locale);
+    }
+    getHover(position, cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getHover.name, this.analysisSettings.initialCorrelationId);
+            const hoverProviderContext = yield this.getHoverProviderContext(position, trace.id, cancellationToken);
+            if (!hoverProviderContext) {
+                trace.exit();
+                return undefined;
+            }
+            const triedHovers = yield Promise.all([
+                this.localDocumentProvider.getHover(hoverProviderContext),
+                this.libraryProvider.getHover(hoverProviderContext),
+            ]);
+            // Keep track if any error was thrown, prioritized by the order of the providers
+            let firstError;
+            for (const triedHover of triedHovers) {
+                if (powerquery_parser_1.ResultUtils.isOk(triedHover)) {
+                    if (triedHover.value !== undefined) {
+                        trace.exit();
+                        return triedHover.value;
+                    }
+                }
+                else if (firstError === undefined) {
+                    firstError = triedHover.error;
+                }
+            }
+            trace.exit();
+            if (firstError !== undefined) {
+                // This is safe as the ensureResultAsync function catch the error.
+                throw firstError;
+            }
+            else {
+                return undefined;
+            }
+        }), this.analysisSettings.inspectionSettings.locale);
+    }
+    // Assumes that initializeState sets parseError to some value, which may include undefined.
+    getParseError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.triedLexParse === undefined) {
+                yield this.initializeState();
+            }
+            return this.parseError;
         });
     }
-    getPartialSemanticTokens() {
+    // Assumes that initializeState sets parseState to some value, which may include undefined.
+    getParseState() {
         return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getPartialSemanticTokens.name, this.analysisSettings.maybeInitialCorrelationId);
+            if (this.triedLexParse === undefined) {
+                yield this.initializeState();
+            }
+            return this.parseState;
+        });
+    }
+    getPartialSemanticTokens(cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getPartialSemanticTokens.name, this.analysisSettings.initialCorrelationId);
             const result = yield this.localDocumentProvider.getPartialSemanticTokens({
                 traceManager: this.analysisSettings.traceManager,
-                maybeInitialCorrelationId: trace.id,
+                initialCorrelationId: trace.id,
+                cancellationToken,
+                library: this.analysisSettings.inspectionSettings.library,
+                parseState: powerquery_parser_1.Assert.asDefined(yield this.getParseState()),
             });
             trace.exit();
-            return result;
-        });
-    }
-    getSignatureHelp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureHelp.name, this.analysisSettings.maybeInitialCorrelationId);
-            const maybeInspected = yield this.promiseMaybeInspected;
-            if (maybeInspected === undefined) {
-                trace.exit();
-                return commonTypes_1.EmptySignatureHelp;
+            if (powerquery_parser_1.ResultUtils.isError(result)) {
+                throw result.error;
             }
-            const maybeContext = yield InspectionUtils.getMaybeContextForSignatureProvider(maybeInspected, this.analysisSettings.traceManager, trace.id);
-            if (maybeContext === undefined) {
+            return result.value;
+        }), this.analysisSettings.inspectionSettings.locale);
+    }
+    getSignatureHelp(position, cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureHelp.name, this.analysisSettings.initialCorrelationId);
+            const signatureProviderContext = yield this.getSignatureProviderContext(position, trace.id, cancellationToken);
+            if (signatureProviderContext === undefined) {
                 trace.exit();
-                return commonTypes_1.EmptySignatureHelp;
+                return undefined;
             }
-            const context = maybeContext;
-            if (context.functionName === undefined) {
-                trace.exit();
-                return commonTypes_1.EmptySignatureHelp;
+            const signatureTasks = yield Promise.all([
+                this.localDocumentProvider.getSignatureHelp(signatureProviderContext),
+                this.libraryProvider.getSignatureHelp(signatureProviderContext),
+            ]);
+            for (const task of signatureTasks) {
+                if (powerquery_parser_1.ResultUtils.isOk(task) && task.value !== undefined) {
+                    trace.exit();
+                    return task.value;
+                }
             }
-            // Result priority is based on the order of the symbol providers
-            const result = AnalysisBase.resolveProviders(AnalysisBase.createSignatureHelpCalls(context, [this.localDocumentProvider, this.librarySymbolProvider], this.analysisSettings.symbolProviderTimeoutInMS), commonTypes_1.EmptySignatureHelp);
             trace.exit();
-            return result;
-        });
+            return undefined;
+        }), this.analysisSettings.inspectionSettings.locale);
     }
-    getRenameEdits(newName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getRenameEdits.name, this.analysisSettings.maybeInitialCorrelationId);
-            const maybeLeafIdentifier = yield this.getActiveLeafIdentifier();
-            const maybeInspected = yield this.promiseMaybeInspected;
-            const scopeById = maybeInspected === null || maybeInspected === void 0 ? void 0 : maybeInspected.typeCache.scopeById;
-            if (maybeInspected === undefined || maybeLeafIdentifier === undefined) {
+    getRenameEdits(position, newName, cancellationToken) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getRenameEdits.name, this.analysisSettings.initialCorrelationId);
+            const activeNode = powerquery_parser_1.Assert.asDefined(yield this.getActiveNode(position));
+            let leafIdentifier;
+            if (!inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode) ||
+                activeNode.inclusiveIdentifierUnderPosition === undefined) {
                 trace.exit();
-                return [];
+                return undefined;
             }
+            else {
+                leafIdentifier = activeNode.inclusiveIdentifierUnderPosition;
+            }
+            void (yield this.inspectNodeScope(activeNode, trace.id, cancellationToken));
+            const scopeById = this.typeCache.scopeById;
             const identifiersToBeEdited = [];
             let valueCreator = undefined;
-            if (maybeLeafIdentifier.node.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
-                valueCreator = maybeLeafIdentifier.node;
+            if (leafIdentifier.node.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+                valueCreator = leafIdentifier.node;
             }
-            else if ((maybeLeafIdentifier.node.kind === "Identifier" /* Identifier */ ||
-                maybeLeafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */) &&
+            else if ((leafIdentifier.node.kind === "Identifier" /* Identifier */ ||
+                leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */) &&
                 scopeById) {
                 // need to find this key value and modify all referring it
-                const identifierExpression = maybeLeafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
-                    ? maybeLeafIdentifier.node.identifier
-                    : maybeLeafIdentifier.node;
+                const identifierExpression = leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                    ? leafIdentifier.node.identifier
+                    : leafIdentifier.node;
                 switch (identifierExpression.identifierContextKind) {
                     case "Key" /* Key */:
                     case "Parameter" /* Parameter */:
@@ -159,29 +251,29 @@ class AnalysisBase {
                         break;
                     case "Value" /* Value */: {
                         // it is the identifier referring the value
-                        let nodeScope = maybeInspected.typeCache.scopeById.get(identifierExpression.id);
+                        let nodeScope = scopeById.get(identifierExpression.id);
                         // there might be a chance that its scope did not get populated yet, do another try
                         if (!nodeScope) {
-                            yield maybeInspected.tryNodeScope(identifierExpression.id);
-                            nodeScope = maybeInspected.typeCache.scopeById.get(identifierExpression.id);
+                            void (yield __1.Inspection.tryNodeScope(this.analysisSettings.inspectionSettings, powerquery_parser_1.Assert.asDefined(yield this.getParseState()).contextState.nodeIdMapCollection, identifierExpression.id, scopeById));
+                            nodeScope = scopeById.get(identifierExpression.id);
                         }
-                        const scopeItem = (0, scopeUtils_1.findScopeItemByLiteral)(nodeScope, maybeLeafIdentifier.normalizedLiteral);
+                        const scopeItem = (0, scopeUtils_1.findScopeItemByLiteral)(nodeScope, leafIdentifier.normalizedLiteral);
                         if (scopeItem) {
-                            const maybeValueCreator = (0, scopeUtils_1.maybeScopeCreatorIdentifier)(scopeItem);
-                            if ((maybeValueCreator === null || maybeValueCreator === void 0 ? void 0 : maybeValueCreator.kind) === "Identifier" /* Identifier */) {
-                                if (maybeValueCreator.identifierContextKind === "Key" /* Key */ ||
-                                    maybeValueCreator.identifierContextKind === "Parameter" /* Parameter */) {
-                                    valueCreator = maybeValueCreator;
+                            const valueCreatorSearch = (0, scopeUtils_1.scopeCreatorIdentifier)(scopeItem);
+                            if ((valueCreatorSearch === null || valueCreatorSearch === void 0 ? void 0 : valueCreatorSearch.kind) === "Identifier" /* Identifier */) {
+                                if (valueCreatorSearch.identifierContextKind === "Key" /* Key */ ||
+                                    valueCreatorSearch.identifierContextKind === "Parameter" /* Parameter */) {
+                                    valueCreator = valueCreatorSearch;
                                 }
                                 else {
-                                    identifiersToBeEdited.push(maybeValueCreator);
+                                    identifiersToBeEdited.push(valueCreatorSearch);
                                 }
                             }
-                            else if ((maybeValueCreator === null || maybeValueCreator === void 0 ? void 0 : maybeValueCreator.kind) === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
-                                valueCreator = maybeValueCreator;
+                            else if ((valueCreatorSearch === null || valueCreatorSearch === void 0 ? void 0 : valueCreatorSearch.kind) === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+                                valueCreator = valueCreatorSearch;
                             }
-                            else if (maybeValueCreator) {
-                                identifiersToBeEdited.push(maybeValueCreator);
+                            else if (valueCreatorSearch) {
+                                identifiersToBeEdited.push(valueCreatorSearch);
                             }
                         }
                         break;
@@ -195,58 +287,31 @@ class AnalysisBase {
             }
             if (valueCreator) {
                 // need to populate the other identifiers referring it
-                identifiersToBeEdited.push(...(yield maybeInspected.collectAllIdentifiersBeneath(valueCreator)));
+                identifiersToBeEdited.push(...(yield this.collectAllIdentifiersBeneath(powerquery_parser_1.Assert.asDefined(yield this.getParseState()).contextState.nodeIdMapCollection, valueCreator)));
             }
-            // if none found, directly put maybeInclusiveIdentifierUnderPosition in if it exists
-            if (identifiersToBeEdited.length === 0 && maybeLeafIdentifier) {
-                identifiersToBeEdited.push(maybeLeafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
-                    ? maybeLeafIdentifier.node.identifier
-                    : maybeLeafIdentifier.node);
+            // if none found, directly put inclusiveIdentifierUnderPosition in if it exists
+            if (identifiersToBeEdited.length === 0 && leafIdentifier) {
+                identifiersToBeEdited.push(leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                    ? leafIdentifier.node.identifier
+                    : leafIdentifier.node);
             }
             const result = identifiersToBeEdited.map((one) => ({
-                range: PositionUtils.createRangeFromTokenRange(one.tokenRange),
+                range: __1.PositionUtils.createRangeFromTokenRange(one.tokenRange),
                 newText: newName,
             }));
             trace.exit();
             return result;
-        });
+        }), this.analysisSettings.inspectionSettings.locale);
     }
-    static promiseWithTimeout(valueFn, timeoutReturnValue, timeoutInMS) {
-        if (timeoutInMS !== undefined) {
-            // TODO: Enabling trace entry when timeout occurs
-            return Promise.race([
-                valueFn(),
-                new Promise((resolve) => setTimeout(() => {
-                    resolve(timeoutReturnValue);
-                }, timeoutInMS)),
-            ]);
+    dispose() {
+        this.typeCache.scopeById.clear();
+        this.typeCache.typeById.clear();
+        for (const token of this.cancellableTokensByAction.values()) {
+            token.cancel();
         }
-        return valueFn();
-    }
-    static resolveProviders(calls, defaultReturnValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield Promise.all(calls);
-            for (let i = 0; i < results.length; i += 1) {
-                const result = results[i];
-                if (result !== null) {
-                    return result;
-                }
-            }
-            return defaultReturnValue;
-        });
-    }
-    static createAutocompleteItemCalls(context, providers, timeoutInMS) {
-        // TODO: add tracing to the catch case
-        return providers.map((provider) => this.promiseWithTimeout(() => provider.getAutocompleteItems(context), [], timeoutInMS));
-    }
-    static createHoverCalls(context, providers, timeoutInMS) {
-        // TODO: add tracing to the catch case
-        return providers.map((provider) => this.promiseWithTimeout(() => provider.getHover(context), null, timeoutInMS));
-    }
-    static createSignatureHelpCalls(context, providers, timeoutInMS) {
-        // TODO: add tracing to the catch case
-        return providers.map((provider) => this.promiseWithTimeout(() => provider.getSignatureHelp(context), null, timeoutInMS));
+        this.cancellableTokensByAction.clear();
     }
+    // protected abstract getText(range?: Range): string;
     static isValidHoverIdentifier(activeNode) {
         var _a;
         const ancestry = activeNode.ancestry;
@@ -265,52 +330,338 @@ class AnalysisBase {
             "GeneralizedIdentifierPairedExpression" /* GeneralizedIdentifierPairedExpression */,
             "IdentifierPairedExpression" /* IdentifierPairedExpression */,
         ].includes(followingNode.node.kind) &&
-            [undefined, 1].includes(powerquery_parser_1.Assert.asDefined(leaf.node.maybeAttributeIndex))) {
+            [undefined, 1].includes(powerquery_parser_1.Assert.asDefined(leaf.node.attributeIndex))) {
             return false;
         }
         return true;
     }
-    getOnIdentifierProviderContext(correlationId) {
+    getAutocompleteItemProviderContext(position, correlationId, newCancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getAutocompleteItemProviderContext.name, correlationId);
+            const activeNode = yield this.getActiveNode(position);
+            if (activeNode === undefined) {
+                trace.exit();
+                return undefined;
+            }
+            const autocomplete = powerquery_parser_1.Assert.asDefined(yield this.inspectAutocomplete(activeNode, trace.id, newCancellationToken));
+            const triedNodeScope = powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, newCancellationToken));
+            const triedScopeType = powerquery_parser_1.Assert.asDefined(yield this.inspectScopeType(activeNode, trace.id, newCancellationToken));
+            const activeLeafIdentifier = inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)
+                ? activeNode.inclusiveIdentifierUnderPosition
+                : undefined;
+            let result;
+            if (activeLeafIdentifier !== undefined) {
+                result = {
+                    autocomplete,
+                    triedNodeScope,
+                    triedScopeType,
+                    traceManager: this.analysisSettings.traceManager,
+                    cancellationToken: newCancellationToken,
+                    initialCorrelationId: trace.id,
+                    range: __1.CommonTypesUtils.rangeFromTokenRange(activeLeafIdentifier.node.tokenRange),
+                    text: activeLeafIdentifier.normalizedLiteral,
+                    tokenKind: activeLeafIdentifier.node.kind,
+                };
+            }
+            else {
+                result = {
+                    autocomplete,
+                    triedNodeScope,
+                    triedScopeType,
+                    traceManager: this.analysisSettings.traceManager,
+                    cancellationToken: newCancellationToken,
+                    initialCorrelationId: trace.id,
+                };
+            }
+            trace.exit();
+            return result;
+        });
+    }
+    getDefinitionProviderContext(position, correlationId, cancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinitionProviderContext.name, correlationId);
+            const activeNode = yield this.getActiveNode(position);
+            if (activeNode === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
+                trace.exit();
+                return undefined;
+            }
+            const identifierUnderPosition = activeNode.exclusiveIdentifierUnderPosition;
+            if (identifierUnderPosition === undefined || !AnalysisBase.isValidHoverIdentifier(activeNode)) {
+                trace.exit();
+                return undefined;
+            }
+            const identifier = identifierUnderPosition.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                ? identifierUnderPosition.node.identifier
+                : identifierUnderPosition.node;
+            const context = {
+                traceManager: this.analysisSettings.traceManager,
+                range: __1.CommonTypesUtils.rangeFromTokenRange(identifier.tokenRange),
+                identifier,
+                cancellationToken,
+                initialCorrelationId: trace.id,
+                triedNodeScope: powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, cancellationToken)),
+            };
+            trace.exit();
+            return context;
+        });
+    }
+    getHoverProviderContext(position, correlationId, cancellationToken) {
         return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinition.name, correlationId);
-            const maybeActiveNode = yield this.getActiveNode();
-            const maybeIdentifierUnderPosition = maybeActiveNode === null || maybeActiveNode === void 0 ? void 0 : maybeActiveNode.maybeExclusiveIdentifierUnderPosition;
-            if (maybeActiveNode === undefined ||
-                maybeIdentifierUnderPosition === undefined ||
-                !AnalysisBase.isValidHoverIdentifier(maybeActiveNode)) {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getHoverProviderContext.name, correlationId);
+            const activeNode = yield this.getActiveNode(position);
+            if (activeNode === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
+                trace.exit();
+                return undefined;
+            }
+            const identifierUnderPosition = activeNode.exclusiveIdentifierUnderPosition;
+            if (identifierUnderPosition === undefined || !AnalysisBase.isValidHoverIdentifier(activeNode)) {
                 trace.exit();
                 return undefined;
             }
-            const identifier = maybeIdentifierUnderPosition.node.kind === "IdentifierExpression" /* IdentifierExpression */
-                ? maybeIdentifierUnderPosition.node.identifier
-                : maybeIdentifierUnderPosition.node;
+            const identifier = identifierUnderPosition.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                ? identifierUnderPosition.node.identifier
+                : identifierUnderPosition.node;
             const context = {
                 traceManager: this.analysisSettings.traceManager,
                 range: __1.CommonTypesUtils.rangeFromTokenRange(identifier.tokenRange),
                 identifier,
-                maybeInitialCorrelationId: trace.id,
+                cancellationToken,
+                initialCorrelationId: trace.id,
+                activeNode,
+                inspectionSettings: Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }),
+                parseState: powerquery_parser_1.Assert.asDefined(yield this.getParseState()),
+                triedNodeScope: powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, cancellationToken)),
+                triedScopeType: powerquery_parser_1.Assert.asDefined(yield this.inspectScopeType(activeNode, trace.id, cancellationToken)),
             };
             trace.exit();
             return context;
         });
     }
-    getActiveNode() {
+    getSignatureProviderContext(position, correlationId, newCancellationToken) {
         return __awaiter(this, void 0, void 0, function* () {
-            const maybeInspected = yield this.promiseMaybeInspected;
-            if (maybeInspected === undefined) {
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureProviderContext.name, correlationId);
+            const triedCurrentInvokeExpression = yield this.inspectCurrentInvokeExpression(position, trace.id, newCancellationToken);
+            if (triedCurrentInvokeExpression === undefined ||
+                powerquery_parser_1.ResultUtils.isError(triedCurrentInvokeExpression) ||
+                triedCurrentInvokeExpression.value === undefined) {
+                trace.exit();
                 return undefined;
             }
-            return __1.Inspection.ActiveNodeUtils.isPositionInBounds(maybeInspected.maybeActiveNode)
-                ? maybeInspected.maybeActiveNode
-                : undefined;
+            const invokeExpression = triedCurrentInvokeExpression.value;
+            const functionName = invokeExpression.name !== undefined ? invokeExpression.name : undefined;
+            const argumentOrdinal = invokeExpression.arguments !== undefined ? invokeExpression.arguments.argumentOrdinal : undefined;
+            if (functionName === undefined || argumentOrdinal === undefined) {
+                trace.exit();
+                return undefined;
+            }
+            const result = {
+                argumentOrdinal,
+                functionName,
+                isNameInLocalScope: invokeExpression.isNameInLocalScope,
+                functionType: invokeExpression.functionType,
+                traceManager: this.analysisSettings.traceManager,
+                cancellationToken: newCancellationToken,
+                initialCorrelationId: trace.id,
+                triedCurrentInvokeExpression: yield __1.Inspection.tryCurrentInvokeExpression(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken: newCancellationToken, initialCorrelationId: trace.id }), powerquery_parser_1.Assert.asDefined(yield this.getParseState()).contextState.nodeIdMapCollection, powerquery_parser_1.Assert.asDefined(yield this.getActiveNode(position)), this.typeCache),
+            };
+            trace.exit();
+            return result;
         });
     }
-    getActiveLeafIdentifier() {
-        var _a;
+    getTypeCache() {
+        return this.typeCache;
+    }
+    collectAllIdentifiersBeneath(nodeIdMapCollection, valueCreator) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const astNodeById = nodeIdMapCollection.astNodeById;
+            const childIdsById = nodeIdMapCollection.childIdsById;
+            const originLiteral = valueCreator.literal;
+            const entry = (0, scopeUtils_1.findDirectUpperScopeExpression)(nodeIdMapCollection, valueCreator.id);
+            if (entry) {
+                const allIdentifierIdSet = (_a = nodeIdMapCollection.idsByNodeKind.get("Identifier" /* Identifier */)) !== null && _a !== void 0 ? _a : new Set();
+                const allGeneralizedIdentifierIdSet = (_b = nodeIdMapCollection.idsByNodeKind.get("GeneralizedIdentifier" /* GeneralizedIdentifier */)) !== null && _b !== void 0 ? _b : new Set();
+                const current = entry;
+                const idsByTiers = [];
+                let currentTier = ((_c = childIdsById.get(current.id)) !== null && _c !== void 0 ? _c : []).slice();
+                while (currentTier.length) {
+                    const toBePushed = currentTier.filter((one) => allIdentifierIdSet.has(one) || allGeneralizedIdentifierIdSet.has(one));
+                    toBePushed.length && idsByTiers.push(toBePushed);
+                    currentTier = currentTier.slice();
+                    let nextTier = [];
+                    while (currentTier.length) {
+                        const oneNode = (_d = currentTier.shift()) !== null && _d !== void 0 ? _d : -1;
+                        const childrenOfTheNode = ((_e = childIdsById.get(oneNode)) !== null && _e !== void 0 ? _e : []).slice();
+                        nextTier = nextTier.concat(childrenOfTheNode);
+                    }
+                    currentTier = nextTier;
+                }
+                // filter literal names
+                const completeIdentifierNodes = idsByTiers
+                    .flat(1)
+                    .map((one) => astNodeById.get(one))
+                    .filter(Boolean);
+                let filteredIdentifierNodes = completeIdentifierNodes.filter((one) => one.literal === originLiteral);
+                // populate the scope items for each
+                yield Promise.all(filteredIdentifierNodes
+                    .filter((oneIdentifier) => oneIdentifier.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */ ||
+                    oneIdentifier.identifierContextKind === "Value" /* Value */)
+                    .map((oneIdentifier) => __1.Inspection.tryNodeScope(this.analysisSettings.inspectionSettings, nodeIdMapCollection, oneIdentifier.id, this.typeCache.scopeById)));
+                filteredIdentifierNodes = filteredIdentifierNodes.filter((oneIdentifierNode) => {
+                    if (oneIdentifierNode.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+                        return oneIdentifierNode.id === valueCreator.id;
+                    }
+                    else if (oneIdentifierNode.identifierContextKind === "Value" /* Value */) {
+                        const theScope = this.typeCache.scopeById.get(oneIdentifierNode.id);
+                        const theScopeItem = (0, scopeUtils_1.findScopeItemByLiteral)(theScope, originLiteral);
+                        const theCreatorIdentifier = (0, scopeUtils_1.scopeCreatorIdentifier)(theScopeItem);
+                        return theCreatorIdentifier && theCreatorIdentifier.id === valueCreator.id;
+                    }
+                    else if (oneIdentifierNode.identifierContextKind === "Key" /* Key */ ||
+                        oneIdentifierNode.identifierContextKind === "Parameter" /* Parameter */) {
+                        return oneIdentifierNode.id === valueCreator.id;
+                    }
+                    return false;
+                });
+                return filteredIdentifierNodes;
+            }
+            return [];
+        });
+    }
+    // Performs a lex + parse of the document, then caches the results into local variables.
+    // Any code which operates on the parse state should use this method to ensure that the parse state is initialized.
+    initializeState() {
         return __awaiter(this, void 0, void 0, function* () {
-            return (_a = (yield this.getActiveNode())) === null || _a === void 0 ? void 0 : _a.maybeInclusiveIdentifierUnderPosition;
+            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.initializeState.name, this.analysisSettings.initialCorrelationId);
+            const updatedSettings = Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { initialCorrelationId: trace.id });
+            const triedLexParse = yield PQP.TaskUtils.tryLexParse(updatedSettings, this.textDocument.getText());
+            this.triedLexParse = triedLexParse;
+            if (PQP.TaskUtils.isLexStageError(triedLexParse) || PQP.TaskUtils.isParseStageCommonError(triedLexParse)) {
+                trace.exit({ ["IsError" /* IsError */]: true });
+            }
+            else if (PQP.TaskUtils.isParseStageError(triedLexParse)) {
+                this.parseState = triedLexParse.parseState;
+                this.parseError = triedLexParse.error;
+            }
+            else {
+                this.parseState = triedLexParse.parseState;
+            }
+            trace.exit();
+        });
+    }
+    // We should only get an undefined for an activeNode iff a parse pass hasn't been done.
+    getActiveNode(position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseState();
+            if (parseState === undefined) {
+                return undefined;
+            }
+            return inspection_1.ActiveNodeUtils.activeNode(parseState.contextState.nodeIdMapCollection, position);
+        });
+    }
+    inspectAutocomplete(activeNode, correlationId, cancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseState();
+            if (parseState === undefined) {
+                return undefined;
+            }
+            return yield __1.Inspection.autocomplete(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }), parseState, this.typeCache, activeNode, yield this.getParseError());
+        });
+    }
+    inspectCurrentInvokeExpression(position, correlationId, cancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeNode = yield this.getActiveNode(position);
+            const parseState = yield this.getParseState();
+            if (activeNode === undefined || parseState === undefined) {
+                return undefined;
+            }
+            return yield __1.Inspection.tryCurrentInvokeExpression(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, activeNode, this.typeCache);
+        });
+    }
+    inspectNodeScope(activeNode, correlationId, cancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseState();
+            if (parseState === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
+                return undefined;
+            }
+            return yield __1.Inspection.tryNodeScope(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, inspection_1.ActiveNodeUtils.assertGetLeaf(activeNode).node.id, this.typeCache.scopeById);
+        });
+    }
+    inspectScopeType(activeNode, correlationId, cancellationToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseState();
+            if (parseState === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
+                return undefined;
+            }
+            return yield __1.Inspection.tryScopeType(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, inspection_1.ActiveNodeUtils.assertGetLeaf(activeNode).node.id, this.typeCache);
         });
     }
 }
 exports.AnalysisBase = AnalysisBase;
+function addIdentifierPairedExpressionSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken) {
+    var _a;
+    const identifierPairedExpressionIds = (_a = nodeIdMapCollection.idsByNodeKind.get("IdentifierPairedExpression" /* IdentifierPairedExpression */)) !== null && _a !== void 0 ? _a : new Set();
+    for (const nodeId of identifierPairedExpressionIds) {
+        cancellationToken.throwIfCancelled();
+        const xorNode = parser_1.NodeIdMapUtils.assertGetXorChecked(nodeIdMapCollection, nodeId, "IdentifierPairedExpression" /* IdentifierPairedExpression */);
+        if (!parser_1.XorNodeUtils.isAstXor(xorNode)) {
+            continue;
+        }
+        const astNode = xorNode.node;
+        const documentSymbol = __1.InspectionUtils.getSymbolForIdentifierPairedExpression(astNode);
+        addDocumentSymbols(nodeIdMapCollection, parentSymbolById, nodeId, currentSymbols, documentSymbol);
+        parentSymbolById.set(nodeId, documentSymbol);
+    }
+}
+function addRecordSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken) {
+    var _a, _b;
+    const recordIdCollections = [
+        (_a = nodeIdMapCollection.idsByNodeKind.get("RecordExpression" /* RecordExpression */)) !== null && _a !== void 0 ? _a : new Set(),
+        (_b = nodeIdMapCollection.idsByNodeKind.get("RecordLiteral" /* RecordLiteral */)) !== null && _b !== void 0 ? _b : new Set(),
+    ];
+    for (const collection of recordIdCollections) {
+        for (const nodeId of collection) {
+            cancellationToken.throwIfCancelled();
+            const xorNode = parser_1.NodeIdMapUtils.assertGetXorChecked(nodeIdMapCollection, nodeId, ["RecordExpression" /* RecordExpression */, "RecordLiteral" /* RecordLiteral */]);
+            if (!parser_1.XorNodeUtils.isAstXor(xorNode)) {
+                continue;
+            }
+            const astNode = xorNode.node;
+            // Process the record if the immediate parent is a Struct
+            const parentId = nodeIdMapCollection.parentIdById.get(astNode.id);
+            const parentSymbol = parentId ? parentSymbolById.get(parentId) : undefined;
+            if (parentSymbol && parentSymbol.kind === vscode_languageserver_types_1.SymbolKind.Struct) {
+                const fieldSymbols = __1.InspectionUtils.getSymbolsForRecord(astNode);
+                if (fieldSymbols.length > 0) {
+                    addDocumentSymbols(nodeIdMapCollection, parentSymbolById, astNode.id, currentSymbols, ...fieldSymbols);
+                }
+            }
+        }
+    }
+}
+function addDocumentSymbols(nodeIdMapCollection, parentSymbolById, nodeId, currentSymbols, ...newSymbols) {
+    const parentSymbol = findParentSymbol(nodeIdMapCollection, parentSymbolById, nodeId);
+    if (parentSymbol) {
+        if (!parentSymbol.children) {
+            parentSymbol.children = [];
+        }
+        parentSymbol.children.push(...newSymbols);
+        return;
+    }
+    // Add to the top level
+    currentSymbols.push(...newSymbols);
+}
+function findParentSymbol(nodeIdMapCollection, parentSymbolById, nodeId) {
+    // Get parent for current node
+    const parentNodeId = nodeIdMapCollection.parentIdById.get(nodeId);
+    if (!parentNodeId) {
+        // No more parents to check
+        return undefined;
+    }
+    let parentSymbol = parentSymbolById.get(parentNodeId);
+    if (!parentSymbol) {
+        parentSymbol = findParentSymbol(nodeIdMapCollection, parentSymbolById, parentNodeId);
+    }
+    return parentSymbol;
+}
 //# sourceMappingURL=analysisBase.js.map