@microsoft/powerquery-language-services 0.6.12 → 0.9.6

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

@@ -16,24 +16,29 @@ const PQP = require("@microsoft/powerquery-parser/lib/powerquery-parser");
 const powerquery_parser_1 = require("@microsoft/powerquery-parser");
 const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
 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`.
+const trace_2 = require("../trace");
+// 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 +48,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(trace_2.ValidationTraceConstant.AnalysisBase, this.getAutocompleteItems.name, this.initialCorrelationId);
+            const context = yield this.getAutocompleteItemProviderContext(position, trace.id, cancellationTokenOverride);
             if (context === undefined) {
                 trace.exit();
                 return undefined;
@@ -70,63 +75,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(trace_2.ValidationTraceConstant.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({ [trace_1.TraceConstant.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(trace_2.ValidationTraceConstant.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({ [trace_1.TraceConstant.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(trace_2.ValidationTraceConstant.AnalysisBase, this.getHover.name, this.initialCorrelationId);
+            const hoverProviderContext = yield this.getHoverProviderContext(position, trace.id, cancellationTokenOverride);
             if (!hoverProviderContext) {
                 trace.exit();
                 return undefined;
@@ -148,59 +156,84 @@ class AnalysisBase {
                     firstError = triedHover.error;
                 }
             }
-            trace.exit();
             if (firstError !== undefined) {
-                // This is safe as the ensureResultAsync function catch the error.
+                trace.exit({ [trace_1.TraceConstant.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(trace_2.ValidationTraceConstant.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({ [trace_1.TraceConstant.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(trace_2.ValidationTraceConstant.AnalysisBase, this.getSignatureHelp.name, this.initialCorrelationId);
+            const signatureProviderContext = yield this.getSignatureProviderContext(position, trace.id, cancellationTokenOverride);
             if (signatureProviderContext === undefined) {
                 trace.exit();
                 return undefined;
@@ -217,62 +250,62 @@ 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(trace_2.ValidationTraceConstant.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;
-            if (leafIdentifier.node.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+            if (leafIdentifier.node.kind === language_1.Ast.NodeKind.GeneralizedIdentifier) {
                 valueCreator = leafIdentifier.node;
             }
-            else if ((leafIdentifier.node.kind === "Identifier" /* Identifier */ ||
-                leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */) &&
+            else if ((leafIdentifier.node.kind === language_1.Ast.NodeKind.Identifier ||
+                leafIdentifier.node.kind === language_1.Ast.NodeKind.IdentifierExpression) &&
                 scopeById) {
                 // need to find this key value and modify all referring it
-                const identifierExpression = leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                const identifierExpression = leafIdentifier.node.kind === language_1.Ast.NodeKind.IdentifierExpression
                     ? leafIdentifier.node.identifier
                     : leafIdentifier.node;
                 switch (identifierExpression.identifierContextKind) {
-                    case "Key" /* Key */:
-                    case "Parameter" /* Parameter */:
+                    case language_1.Ast.IdentifierContextKind.Key:
+                    case language_1.Ast.IdentifierContextKind.Parameter:
                         // it is the identifier creating the value
                         valueCreator = identifierExpression;
                         break;
-                    case "Value" /* Value */: {
+                    case language_1.Ast.IdentifierContextKind.Value: {
                         // it is the identifier referring the value
                         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);
                         if (scopeItem) {
                             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 */) {
+                            if ((valueCreatorSearch === null || valueCreatorSearch === void 0 ? void 0 : valueCreatorSearch.kind) === language_1.Ast.NodeKind.Identifier) {
+                                if (valueCreatorSearch.identifierContextKind === language_1.Ast.IdentifierContextKind.Key ||
+                                    valueCreatorSearch.identifierContextKind === language_1.Ast.IdentifierContextKind.Parameter) {
                                     valueCreator = valueCreatorSearch;
                                 }
                                 else {
                                     identifiersToBeEdited.push(valueCreatorSearch);
                                 }
                             }
-                            else if ((valueCreatorSearch === null || valueCreatorSearch === void 0 ? void 0 : valueCreatorSearch.kind) === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+                            else if ((valueCreatorSearch === null || valueCreatorSearch === void 0 ? void 0 : valueCreatorSearch.kind) === language_1.Ast.NodeKind.GeneralizedIdentifier) {
                                 valueCreator = valueCreatorSearch;
                             }
                             else if (valueCreatorSearch) {
@@ -281,7 +314,7 @@ class AnalysisBase {
                         }
                         break;
                     }
-                    case "Keyword" /* Keyword */:
+                    case language_1.Ast.IdentifierContextKind.Keyword:
                     default:
                         // only modify once
                         identifiersToBeEdited.push(identifierExpression);
@@ -290,72 +323,58 @@ 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) {
-                identifiersToBeEdited.push(leafIdentifier.node.kind === "IdentifierExpression" /* IdentifierExpression */
+                identifiersToBeEdited.push(leafIdentifier.node.kind === language_1.Ast.NodeKind.IdentifierExpression
                     ? leafIdentifier.node.identifier
                     : 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) === language_1.Ast.NodeKind.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(trace_2.ValidationTraceConstant.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 +386,8 @@ class AnalysisBase {
                     autocomplete,
                     triedNodeScope,
                     triedScopeType,
-                    traceManager: this.analysisSettings.traceManager,
-                    cancellationToken: newCancellationToken,
+                    traceManager: this.traceManager,
+                    cancellationToken,
                     initialCorrelationId: trace.id,
                 };
             }
@@ -376,39 +395,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(trace_2.ValidationTraceConstant.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 */
+            const identifier = identifierUnderPosition.node.kind === language_1.Ast.NodeKind.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(trace_2.ValidationTraceConstant.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 +437,35 @@ class AnalysisBase {
                 trace.exit();
                 return undefined;
             }
-            const identifier = identifierUnderPosition.node.kind === "IdentifierExpression" /* IdentifierExpression */
+            const cancellationToken = cancellationTokenOverride !== null && cancellationTokenOverride !== void 0 ? cancellationTokenOverride : this.inspectionSettings.cancellationToken;
+            const identifier = identifierUnderPosition.node.kind === language_1.Ast.NodeKind.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(trace_2.ValidationTraceConstant.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 +478,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;
@@ -478,8 +504,8 @@ class AnalysisBase {
             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 allIdentifierIdSet = (_a = nodeIdMapCollection.idsByNodeKind.get(language_1.Ast.NodeKind.Identifier)) !== null && _a !== void 0 ? _a : new Set();
+                const allGeneralizedIdentifierIdSet = (_b = nodeIdMapCollection.idsByNodeKind.get(language_1.Ast.NodeKind.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();
@@ -503,21 +529,21 @@ class AnalysisBase {
                 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)));
+                    .filter((oneIdentifier) => oneIdentifier.kind === language_1.Ast.NodeKind.GeneralizedIdentifier ||
+                    oneIdentifier.identifierContextKind === language_1.Ast.IdentifierContextKind.Value)
+                    .map((oneIdentifier) => __1.Inspection.tryNodeScope(this.inspectionSettings, nodeIdMapCollection, oneIdentifier.id, this.typeCache.scopeById)));
                 filteredIdentifierNodes = filteredIdentifierNodes.filter((oneIdentifierNode) => {
-                    if (oneIdentifierNode.kind === "GeneralizedIdentifier" /* GeneralizedIdentifier */) {
+                    if (oneIdentifierNode.kind === language_1.Ast.NodeKind.GeneralizedIdentifier) {
                         return oneIdentifierNode.id === valueCreator.id;
                     }
-                    else if (oneIdentifierNode.identifierContextKind === "Value" /* Value */) {
+                    else if (oneIdentifierNode.identifierContextKind === language_1.Ast.IdentifierContextKind.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 */) {
+                    else if (oneIdentifierNode.identifierContextKind === language_1.Ast.IdentifierContextKind.Key ||
+                        oneIdentifierNode.identifierContextKind === language_1.Ast.IdentifierContextKind.Parameter) {
                         return oneIdentifierNode.id === valueCreator.id;
                     }
                     return false;
@@ -529,81 +555,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(trace_2.ValidationTraceConstant.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({ [trace_1.TraceConstant.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({ [trace_1.TraceConstant.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({ [trace_1.TraceConstant.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();
+    const identifierPairedExpressionIds = (_a = nodeIdMapCollection.idsByNodeKind.get(language_1.Ast.NodeKind.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, language_1.Ast.NodeKind.IdentifierPairedExpression);
+        if (!parser_1.XorNodeUtils.isAst(xorNode)) {
             continue;
         }
         const astNode = xorNode.node;
@@ -615,14 +659,14 @@ function addIdentifierPairedExpressionSymbols(nodeIdMapCollection, currentSymbol
 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(),
+        (_a = nodeIdMapCollection.idsByNodeKind.get(language_1.Ast.NodeKind.RecordExpression)) !== null && _a !== void 0 ? _a : new Set(),
+        (_b = nodeIdMapCollection.idsByNodeKind.get(language_1.Ast.NodeKind.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)) {
+            cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancelled();
+            const xorNode = parser_1.NodeIdMapUtils.assertXorChecked(nodeIdMapCollection, nodeId, [language_1.Ast.NodeKind.RecordExpression, language_1.Ast.NodeKind.RecordLiteral]);
+            if (!parser_1.XorNodeUtils.isAst(xorNode)) {
                 continue;
             }
             const astNode = xorNode.node;