@microsoft/powerquery-language-services 0.6.11 → 0.9.2

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

@@ -20,20 +20,22 @@ const inspection_1 = require("../inspection");
 const __1 = require("..");
 const scopeUtils_1 = require("../inspection/scope/scopeUtils");
 const providers_1 = require("../providers");
-// Implementation of Analysis, subclass it as needed.
-// Does not implement `dispose`.
+// Implementation of Analysis.
+// All public methods should:
+//  - use ensureResultAsync to ensure a Result, allowing all protected methods to safetly throw.
+//  - take an optional cancellation token.
 class AnalysisBase {
     constructor(textDocument, analysisSettings) {
         this.textDocument = textDocument;
-        this.analysisSettings = analysisSettings;
-        // Shared across actions
-        this.parseError = undefined;
-        this.parseState = undefined;
-        this.triedLexParse = undefined;
+        // Local type cache that is shared across provider actions.
         this.typeCache = {
             scopeById: new Map(),
             typeById: new Map(),
         };
+        this.initialCorrelationId = analysisSettings.initialCorrelationId;
+        this.inspectionSettings = analysisSettings.inspectionSettings;
+        this.locale = analysisSettings.inspectionSettings.locale;
+        this.traceManager = analysisSettings.traceManager;
         this.languageAutocompleteItemProvider = analysisSettings.languageAutocompleteItemProviderFactory
             ? analysisSettings.languageAutocompleteItemProviderFactory(analysisSettings.inspectionSettings.locale)
             : new providers_1.LanguageAutocompleteItemProvider(analysisSettings.inspectionSettings.locale);
@@ -43,12 +45,12 @@ class AnalysisBase {
         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();
+        this.triedLexParse = this.tryLexParse();
     }
-    getAutocompleteItems(position, cancellationToken) {
+    getAutocompleteItems(position, cancellationTokenOverride) {
         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);
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getAutocompleteItems.name, this.initialCorrelationId);
+            const context = yield this.getAutocompleteItemProviderContext(position, trace.id, cancellationTokenOverride);
             if (context === undefined) {
                 trace.exit();
                 return undefined;
@@ -70,63 +72,66 @@ class AnalysisBase {
             }
             trace.exit();
             return autocompleteItems;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getDefinition(position, cancellationToken) {
+    getDefinition(position, cancellationTokenOverride) {
         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);
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinition.name, this.initialCorrelationId);
+            const identifierContext = yield this.getDefinitionProviderContext(position, trace.id, cancellationTokenOverride);
             if (!identifierContext) {
                 trace.exit();
                 return undefined;
             }
             const result = yield this.localDocumentProvider.getDefinition(identifierContext);
-            trace.exit();
             if (powerquery_parser_1.ResultUtils.isError(result)) {
+                trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
                 throw result.error;
             }
+            trace.exit();
             return result.value;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getDocumentSymbols(cancellationToken) {
+    getDocumentSymbols(cancellationTokenOverride) {
         return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
-            const parseState = yield this.getParseState();
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
             if (parseState === undefined) {
                 return undefined;
             }
             const nodeIdMapCollection = parseState.contextState.nodeIdMapCollection;
             const currentSymbols = [];
             const parentSymbolById = new Map();
+            const cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
             addIdentifierPairedExpressionSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken);
             addRecordSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById, cancellationToken);
             return currentSymbols;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getFoldingRanges(cancellationToken) {
+    getFoldingRanges(cancellationTokenOverride) {
         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();
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getFoldingRanges.name, this.initialCorrelationId);
+            const parseState = yield this.getParseStateOkOrThrow(trace);
             if (parseState === undefined) {
                 trace.exit();
                 return undefined;
             }
             const result = yield this.localDocumentProvider.getFoldingRanges({
-                traceManager: this.analysisSettings.traceManager,
+                traceManager: this.traceManager,
                 initialCorrelationId: trace.id,
-                cancellationToken,
+                cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken,
                 nodeIdMapCollection: parseState.contextState.nodeIdMapCollection,
             });
-            trace.exit();
             if (powerquery_parser_1.ResultUtils.isError(result)) {
+                trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
                 throw result.error;
             }
+            trace.exit();
             return result.value;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getHover(position, cancellationToken) {
+    getHover(position, cancellationTokenOverride) {
         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);
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getHover.name, this.initialCorrelationId);
+            const hoverProviderContext = yield this.getHoverProviderContext(position, trace.id, cancellationTokenOverride);
             if (!hoverProviderContext) {
                 trace.exit();
                 return undefined;
@@ -148,59 +153,84 @@ class AnalysisBase {
                     firstError = triedHover.error;
                 }
             }
-            trace.exit();
             if (firstError !== undefined) {
-                // This is safe as the ensureResultAsync function catch the error.
+                trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
                 throw firstError;
             }
-            else {
+            trace.exit();
+            return undefined;
+        }), this.locale);
+    }
+    // We should only get an undefined for an activeNode iff a parse pass hasn't been done.
+    getActiveNode(position) {
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
+            if (parseState === undefined) {
                 return undefined;
             }
-        }), this.analysisSettings.inspectionSettings.locale);
+            return inspection_1.ActiveNodeUtils.activeNode(parseState.contextState.nodeIdMapCollection, position);
+        }), this.locale);
     }
-    // Assumes that initializeState sets parseError to some value, which may include undefined.
+    // undefined means either the parse pass wasn't done (lexing error), or there was no error.
     getParseError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.triedLexParse === undefined) {
-                yield this.initializeState();
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const triedLexParse = yield this.triedLexParse;
+            if (PQP.TaskUtils.isParseStageCommonError(triedLexParse)) {
+                throw triedLexParse.error;
             }
-            return this.parseError;
-        });
+            else if (PQP.TaskUtils.isParseStageError(triedLexParse)) {
+                return triedLexParse.error;
+            }
+            else {
+                return undefined;
+            }
+        }), this.locale);
     }
-    // Assumes that initializeState sets parseState to some value, which may include undefined.
+    // We should only get an undefined for an activeNode iff a parse pass hasn't been done.
     getParseState() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.triedLexParse === undefined) {
-                yield this.initializeState();
+        return powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
+            const triedLexParse = yield this.triedLexParse;
+            if (PQP.TaskUtils.isParseStageCommonError(triedLexParse)) {
+                throw triedLexParse.error;
             }
-            return this.parseState;
-        });
+            else if (PQP.TaskUtils.isParseStageError(triedLexParse)) {
+                return triedLexParse.parseState;
+            }
+            else if (PQP.TaskUtils.isParseStageOk(triedLexParse)) {
+                return triedLexParse.parseState;
+            }
+            else {
+                return undefined;
+            }
+        }), this.locale);
     }
-    getPartialSemanticTokens(cancellationToken) {
+    getPartialSemanticTokens(cancellationTokenOverride) {
         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 parseState = yield this.getParseState();
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getPartialSemanticTokens.name, this.initialCorrelationId);
+            const parseState = yield this.getParseStateOkOrThrow(trace);
             if (parseState === undefined) {
+                trace.exit();
                 return undefined;
             }
             const result = yield this.localDocumentProvider.getPartialSemanticTokens({
-                traceManager: this.analysisSettings.traceManager,
+                traceManager: this.traceManager,
                 initialCorrelationId: trace.id,
-                cancellationToken,
-                library: this.analysisSettings.inspectionSettings.library,
+                cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken,
+                library: this.inspectionSettings.library,
                 parseState,
             });
-            trace.exit();
             if (powerquery_parser_1.ResultUtils.isError(result)) {
+                trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
                 throw result.error;
             }
+            trace.exit();
             return result.value;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getSignatureHelp(position, cancellationToken) {
+    getSignatureHelp(position, cancellationTokenOverride) {
         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);
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureHelp.name, this.initialCorrelationId);
+            const signatureProviderContext = yield this.getSignatureProviderContext(position, trace.id, cancellationTokenOverride);
             if (signatureProviderContext === undefined) {
                 trace.exit();
                 return undefined;
@@ -217,22 +247,22 @@ class AnalysisBase {
             }
             trace.exit();
             return undefined;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
-    getRenameEdits(position, newName, cancellationToken) {
+    getRenameEdits(position, newName, cancellationTokenOverride) {
         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) ||
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getRenameEdits.name, this.initialCorrelationId);
+            const parseState = yield this.getParseStateOkOrThrow(trace);
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, trace);
+            if (parseState === undefined ||
+                activeNode === undefined ||
+                !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode) ||
                 activeNode.inclusiveIdentifierUnderPosition === undefined) {
                 trace.exit();
                 return undefined;
             }
-            else {
-                leafIdentifier = activeNode.inclusiveIdentifierUnderPosition;
-            }
-            void (yield this.inspectNodeScope(activeNode, trace.id, cancellationToken));
+            void (yield this.inspectNodeScope(activeNode, trace.id, cancellationTokenOverride));
+            const leafIdentifier = activeNode.inclusiveIdentifierUnderPosition;
             const scopeById = this.typeCache.scopeById;
             const identifiersToBeEdited = [];
             let valueCreator = undefined;
@@ -257,7 +287,7 @@ class AnalysisBase {
                         let nodeScope = scopeById.get(identifierExpression.id);
                         // there might be a chance that its scope did not get populated yet, do another try
                         if (!nodeScope) {
-                            void (yield __1.Inspection.tryNodeScope(this.analysisSettings.inspectionSettings, powerquery_parser_1.Assert.asDefined(yield this.getParseState()).contextState.nodeIdMapCollection, identifierExpression.id, scopeById));
+                            void (yield __1.Inspection.tryNodeScope(this.inspectionSettings, parseState.contextState.nodeIdMapCollection, identifierExpression.id, scopeById));
                             nodeScope = scopeById.get(identifierExpression.id);
                         }
                         const scopeItem = (0, scopeUtils_1.findScopeItemByLiteral)(nodeScope, leafIdentifier.normalizedLiteral);
@@ -290,7 +320,7 @@ class AnalysisBase {
             }
             if (valueCreator) {
                 // need to populate the other identifiers referring it
-                identifiersToBeEdited.push(...(yield this.collectAllIdentifiersBeneath(powerquery_parser_1.Assert.asDefined(yield this.getParseState()).contextState.nodeIdMapCollection, valueCreator)));
+                identifiersToBeEdited.push(...(yield this.collectAllIdentifiersBeneath(parseState.contextState.nodeIdMapCollection, valueCreator)));
             }
             // if none found, directly put inclusiveIdentifierUnderPosition in if it exists
             if (identifiersToBeEdited.length === 0 && leafIdentifier) {
@@ -299,63 +329,49 @@ class AnalysisBase {
                     : leafIdentifier.node);
             }
             const result = identifiersToBeEdited.map((one) => ({
-                range: __1.PositionUtils.createRangeFromTokenRange(one.tokenRange),
+                range: __1.PositionUtils.rangeFromTokenRange(one.tokenRange),
                 newText: newName,
             }));
             trace.exit();
             return result;
-        }), this.analysisSettings.inspectionSettings.locale);
+        }), this.locale);
     }
     dispose() {
         this.typeCache.scopeById.clear();
         this.typeCache.typeById.clear();
     }
-    // protected abstract getText(range?: Range): string;
     static isValidHoverIdentifier(activeNode) {
         var _a;
         const ancestry = activeNode.ancestry;
-        if (ancestry.length <= 1) {
-            return true;
-        }
-        const leaf = powerquery_parser_1.Assert.asDefined(ancestry[0]);
-        const followingNode = ancestry[1];
-        if (((_a = followingNode === null || followingNode === void 0 ? void 0 : followingNode.node) === null || _a === void 0 ? void 0 : _a.kind) === "Parameter" /* Parameter */) {
-            return false;
-        }
-        // Allow hover on either the key or value of [Generalized|Identifier]PairedExpression.
-        // Validate it's not an incomplete Ast or that you're on the conjunction.
-        else if ([
-            "GeneralizedIdentifierPairedAnyLiteral" /* GeneralizedIdentifierPairedAnyLiteral */,
-            "GeneralizedIdentifierPairedExpression" /* GeneralizedIdentifierPairedExpression */,
-            "IdentifierPairedExpression" /* IdentifierPairedExpression */,
-        ].includes(followingNode.node.kind) &&
-            [undefined, 1].includes(powerquery_parser_1.Assert.asDefined(leaf.node.attributeIndex))) {
+        const parent = ancestry[1];
+        if (((_a = parent === null || parent === void 0 ? void 0 : parent.node) === null || _a === void 0 ? void 0 : _a.kind) === "Parameter" /* Parameter */) {
             return false;
         }
         return true;
     }
-    getAutocompleteItemProviderContext(position, correlationId, newCancellationToken) {
+    getAutocompleteItemProviderContext(position, correlationId, cancellationTokenOverride) {
         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) {
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getAutocompleteItemProviderContext.name, correlationId);
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, trace);
+            if (activeNode === undefined || (inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode) && activeNode.isInKey)) {
                 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 autocomplete = powerquery_parser_1.Assert.asDefined(yield this.inspectAutocomplete(activeNode, trace.id, cancellationTokenOverride), "we have a truthy activeNode meaning we have a truthy parseState");
+            const triedNodeScope = powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, cancellationTokenOverride), "we have a truthy activeNode meaning we have a truthy parseState");
+            const triedScopeType = powerquery_parser_1.Assert.asDefined(yield this.inspectScopeType(activeNode, trace.id, cancellationTokenOverride), "we have a truthy activeNode meaning we have a truthy parseState");
             const activeLeafIdentifier = inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)
                 ? activeNode.inclusiveIdentifierUnderPosition
                 : undefined;
             let result;
+            const cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
             if (activeLeafIdentifier !== undefined) {
                 result = {
                     autocomplete,
                     triedNodeScope,
                     triedScopeType,
-                    traceManager: this.analysisSettings.traceManager,
-                    cancellationToken: newCancellationToken,
+                    traceManager: this.traceManager,
+                    cancellationToken,
                     initialCorrelationId: trace.id,
                     range: __1.CommonTypesUtils.rangeFromTokenRange(activeLeafIdentifier.node.tokenRange),
                     text: activeLeafIdentifier.normalizedLiteral,
@@ -367,8 +383,8 @@ class AnalysisBase {
                     autocomplete,
                     triedNodeScope,
                     triedScopeType,
-                    traceManager: this.analysisSettings.traceManager,
-                    cancellationToken: newCancellationToken,
+                    traceManager: this.traceManager,
+                    cancellationToken,
                     initialCorrelationId: trace.id,
                 };
             }
@@ -376,39 +392,40 @@ class AnalysisBase {
             return result;
         });
     }
-    getDefinitionProviderContext(position, correlationId, cancellationToken) {
+    getDefinitionProviderContext(position, correlationId, cancellationTokenOverride) {
         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)) {
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getDefinitionProviderContext.name, correlationId);
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, trace);
+            if (activeNode === undefined ||
+                !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode) ||
+                activeNode.exclusiveIdentifierUnderPosition === undefined ||
+                !AnalysisBase.isValidHoverIdentifier(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 cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
             const context = {
-                traceManager: this.analysisSettings.traceManager,
+                traceManager: this.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)),
+                cancellationToken,
+                identifier,
+                triedNodeScope: powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, cancellationToken), "we got a truthy activeNode meaning we have a truthy parseState"),
             };
             trace.exit();
             return context;
         });
     }
-    getHoverProviderContext(position, correlationId, cancellationToken) {
+    getHoverProviderContext(position, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            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)) {
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getHoverProviderContext.name, correlationId);
+            const parseState = yield this.getParseStateOkOrThrow(trace);
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, trace);
+            if (parseState === undefined || activeNode === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
                 trace.exit();
                 return undefined;
             }
@@ -417,30 +434,35 @@ class AnalysisBase {
                 trace.exit();
                 return undefined;
             }
+            const cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
             const identifier = identifierUnderPosition.node.kind === "IdentifierExpression" /* IdentifierExpression */
                 ? identifierUnderPosition.node.identifier
                 : identifierUnderPosition.node;
             const context = {
-                traceManager: this.analysisSettings.traceManager,
+                traceManager: this.traceManager,
                 range: __1.CommonTypesUtils.rangeFromTokenRange(identifier.tokenRange),
                 identifier,
                 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)),
+                inspectionSettings: Object.assign(Object.assign({}, this.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }),
+                parseState,
+                triedNodeScope: powerquery_parser_1.Assert.asDefined(yield this.inspectNodeScope(activeNode, trace.id, cancellationToken), "we have a truthy activeNode meaning we have a truthy parseState"),
+                triedScopeType: powerquery_parser_1.Assert.asDefined(yield this.inspectScopeType(activeNode, trace.id, cancellationToken), "we have a truthy activeNode meaning we have a truthy parseState"),
             };
             trace.exit();
             return context;
         });
     }
-    getSignatureProviderContext(position, correlationId, newCancellationToken) {
+    getSignatureProviderContext(position, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            const trace = this.analysisSettings.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureProviderContext.name, correlationId);
-            const triedCurrentInvokeExpression = yield this.inspectCurrentInvokeExpression(position, trace.id, newCancellationToken);
-            if (triedCurrentInvokeExpression === undefined ||
+            const trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.getSignatureProviderContext.name, correlationId);
+            const parseState = yield this.getParseStateOkOrThrow(trace);
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, trace);
+            const triedCurrentInvokeExpression = yield this.inspectCurrentInvokeExpression(position, trace.id, cancellationTokenOverride);
+            if (parseState === undefined ||
+                activeNode === undefined ||
+                triedCurrentInvokeExpression === undefined ||
                 powerquery_parser_1.ResultUtils.isError(triedCurrentInvokeExpression) ||
                 triedCurrentInvokeExpression.value === undefined) {
                 trace.exit();
@@ -453,15 +475,16 @@ class AnalysisBase {
                 trace.exit();
                 return undefined;
             }
+            const cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
             const result = {
                 argumentOrdinal,
                 functionName,
                 isNameInLocalScope: invokeExpression.isNameInLocalScope,
                 functionType: invokeExpression.functionType,
-                traceManager: this.analysisSettings.traceManager,
-                cancellationToken: newCancellationToken,
+                traceManager: this.traceManager,
+                cancellationToken,
                 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),
+                triedCurrentInvokeExpression: yield __1.Inspection.tryCurrentInvokeExpression(Object.assign(Object.assign({}, this.inspectionSettings), { cancellationToken, initialCorrelationId: trace.id }), parseState.contextState.nodeIdMapCollection, activeNode, this.typeCache),
             };
             trace.exit();
             return result;
@@ -505,7 +528,7 @@ class AnalysisBase {
                 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)));
+                    .map((oneIdentifier) => __1.Inspection.tryNodeScope(this.inspectionSettings, nodeIdMapCollection, oneIdentifier.id, this.typeCache.scopeById)));
                 filteredIdentifierNodes = filteredIdentifierNodes.filter((oneIdentifierNode) => {
                     if (oneIdentifierNode.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
                         return oneIdentifierNode.id === valueCreator.id;
@@ -529,81 +552,99 @@ class AnalysisBase {
     }
     // 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() {
+    tryLexParse() {
         return __awaiter(this, void 0, void 0, function* () {
-            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 trace = this.traceManager.entry("AnalysisBase" /* AnalysisBase */, this.tryLexParse.name, this.initialCorrelationId);
+            const updatedSettings = Object.assign(Object.assign({}, this.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();
+            return triedLexParse;
         });
     }
-    // We should only get an undefined for an activeNode iff a parse pass hasn't been done.
-    getActiveNode(position) {
+    inspectAutocomplete(activeNode, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            const parseState = yield this.getParseState();
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
+            const parseError = yield this.getParseErrorOkOrThrow(undefined);
             if (parseState === undefined) {
                 return undefined;
             }
-            return inspection_1.ActiveNodeUtils.activeNode(parseState.contextState.nodeIdMapCollection, position);
+            return yield __1.Inspection.autocomplete(Object.assign(Object.assign({}, this.inspectionSettings), { initialCorrelationId: correlationId, cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken }), parseState, this.typeCache, activeNode, parseError);
         });
     }
-    inspectAutocomplete(activeNode, correlationId, cancellationToken) {
+    inspectCurrentInvokeExpression(position, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            const parseState = yield this.getParseState();
-            if (parseState === undefined) {
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
+            // parseState needs to be ok, and must be truthy.
+            const activeNode = yield this.getActiveNodeOkOrThrow(position, undefined);
+            if (parseState === undefined || activeNode === 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());
+            return yield __1.Inspection.tryCurrentInvokeExpression(Object.assign(Object.assign({}, this.inspectionSettings), { initialCorrelationId: correlationId, cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken }), parseState.contextState.nodeIdMapCollection, activeNode, this.typeCache);
         });
     }
-    inspectCurrentInvokeExpression(position, correlationId, cancellationToken) {
+    inspectNodeScope(activeNode, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            const activeNode = yield this.getActiveNode(position);
-            const parseState = yield this.getParseState();
-            if (activeNode === undefined || parseState === undefined) {
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
+            if (parseState === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
                 return undefined;
             }
-            return yield __1.Inspection.tryCurrentInvokeExpression(Object.assign(Object.assign({}, this.analysisSettings.inspectionSettings), { cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, activeNode, this.typeCache);
+            return yield __1.Inspection.tryNodeScope(Object.assign(Object.assign({}, this.inspectionSettings), { cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, inspection_1.ActiveNodeUtils.assertGetLeaf(activeNode).node.id, this.typeCache.scopeById);
         });
     }
-    inspectNodeScope(activeNode, correlationId, cancellationToken) {
+    inspectScopeType(activeNode, correlationId, cancellationTokenOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            const parseState = yield this.getParseState();
+            const parseState = yield this.getParseStateOkOrThrow(undefined);
             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);
+            return yield __1.Inspection.tryScopeType(Object.assign(Object.assign({}, this.inspectionSettings), { cancellationToken: cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken, initialCorrelationId: correlationId }), parseState.contextState.nodeIdMapCollection, inspection_1.ActiveNodeUtils.assertGetLeaf(activeNode).node.id, this.typeCache);
         });
     }
-    inspectScopeType(activeNode, correlationId, cancellationToken) {
+    getActiveNodeOkOrThrow(position, trace) {
         return __awaiter(this, void 0, void 0, function* () {
-            const parseState = yield this.getParseState();
-            if (parseState === undefined || !inspection_1.ActiveNodeUtils.isPositionInBounds(activeNode)) {
-                return undefined;
+            const activeNodeResult = yield this.getActiveNode(position);
+            if (powerquery_parser_1.ResultUtils.isError(activeNodeResult)) {
+                trace === null || trace === void 0 ? void 0 : trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
+                throw activeNodeResult.error;
             }
-            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);
+            return activeNodeResult.value;
         });
     }
+    getParseErrorOkOrThrow(trace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseErrorResult = yield this.getParseError();
+            if (powerquery_parser_1.ResultUtils.isError(parseErrorResult)) {
+                trace === null || trace === void 0 ? void 0 : trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
+                throw parseErrorResult.error;
+            }
+            return parseErrorResult.value;
+        });
+    }
+    getParseStateOkOrThrow(trace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parseStateResult = yield this.getParseState();
+            if (powerquery_parser_1.ResultUtils.isError(parseStateResult)) {
+                trace === null || trace === void 0 ? void 0 : trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
+                throw parseStateResult.error;
+            }
+            return parseStateResult.value;
+        });
+    }
+    applyAnalysisSettings(analysisSettings) {
+        this.initialCorrelationId = analysisSettings.initialCorrelationId;
+        this.inspectionSettings = analysisSettings.inspectionSettings;
+        this.locale = analysisSettings.inspectionSettings.locale;
+        this.traceManager = analysisSettings.traceManager;
+    }
 }
 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)) {
+        cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancelled();
+        const xorNode = parser_1.NodeIdMapUtils.assertXorChecked(nodeIdMapCollection, nodeId, "IdentifierPairedExpression" /* IdentifierPairedExpression */);
+        if (!parser_1.XorNodeUtils.isAst(xorNode)) {
             continue;
         }
         const astNode = xorNode.node;
@@ -620,9 +661,9 @@ function addRecordSymbols(nodeIdMapCollection, currentSymbols, parentSymbolById,
     ];
     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)) {
+            cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancelled();
+            const xorNode = parser_1.NodeIdMapUtils.assertXorChecked(nodeIdMapCollection, nodeId, ["RecordExpression" /* RecordExpression */, "RecordLiteral" /* RecordLiteral */]);
+            if (!parser_1.XorNodeUtils.isAst(xorNode)) {
                 continue;
             }
             const astNode = xorNode.node;