@microsoft/powerquery-language-services 0.10.6 → 0.11.1

package/lib/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifier.d.ts

@@ -1,37 +1,37 @@
-import { TPowerQueryType } from "@microsoft/powerquery-parser/lib/powerquery-parser/language/type/type";
-import { TXorNode } from "@microsoft/powerquery-parser/lib/powerquery-parser/parser";
-import { TScopeItem } from "../scope";
-export declare enum DereferencedIdentifierKind {
-    External = "External",
-    InScopeDereference = "InScopeDereference",
-    InScopeValue = "InScopeValue",
-    Recursive = "Recursive",
-    Undefined = "Undefined"
-}
-export interface IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind;
-    readonly xorNode: TXorNode;
-}
-export interface DereferencedIdentifierExternal extends IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind.External;
-    readonly identifierLiteral: string;
-    readonly type: TPowerQueryType;
-}
-export interface DereferencedIdentifierInScopeDereference extends IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind.InScopeDereference;
-    readonly identifierLiteral: string;
-    readonly nextScopeItem: TScopeItem;
-}
-export interface DereferencedIdentifierInScopeValue extends IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind.InScopeValue;
-    readonly scopeItem: TScopeItem;
-}
-export interface DereferencedIdentifierRecursive extends IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind.Recursive;
-    readonly identifierLiteral: string;
-}
-export interface DereferencedIdentifierUndefined extends IDereferencedIdentifier {
-    readonly kind: DereferencedIdentifierKind.Undefined;
-    readonly identifierLiteral: string;
-}
-export declare type TDereferencedIdentifier = DereferencedIdentifierExternal | DereferencedIdentifierInScopeDereference | DereferencedIdentifierInScopeValue | DereferencedIdentifierRecursive | DereferencedIdentifierUndefined;
+import { TPowerQueryType } from "@microsoft/powerquery-parser/lib/powerquery-parser/language/type/type";
+import { TXorNode } from "@microsoft/powerquery-parser/lib/powerquery-parser/parser";
+import { TScopeItem } from "../scope";
+export declare enum DereferencedIdentifierKind {
+    External = "External",
+    InScopeDereference = "InScopeDereference",
+    InScopeValue = "InScopeValue",
+    Recursive = "Recursive",
+    Undefined = "Undefined"
+}
+export interface IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind;
+    readonly xorNode: TXorNode;
+}
+export interface DereferencedIdentifierExternal extends IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind.External;
+    readonly identifierLiteral: string;
+    readonly type: TPowerQueryType;
+}
+export interface DereferencedIdentifierInScopeDereference extends IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind.InScopeDereference;
+    readonly identifierLiteral: string;
+    readonly nextScopeItem: TScopeItem;
+}
+export interface DereferencedIdentifierInScopeValue extends IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind.InScopeValue;
+    readonly scopeItem: TScopeItem;
+}
+export interface DereferencedIdentifierRecursive extends IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind.Recursive;
+    readonly identifierLiteral: string;
+}
+export interface DereferencedIdentifierUndefined extends IDereferencedIdentifier {
+    readonly kind: DereferencedIdentifierKind.Undefined;
+    readonly identifierLiteral: string;
+}
+export type TDereferencedIdentifier = DereferencedIdentifierExternal | DereferencedIdentifierInScopeDereference | DereferencedIdentifierInScopeValue | DereferencedIdentifierRecursive | DereferencedIdentifierUndefined;

package/lib/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifier.js

@@ -1,14 +1,14 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DereferencedIdentifierKind = void 0;
-var DereferencedIdentifierKind;
-(function (DereferencedIdentifierKind) {
-    DereferencedIdentifierKind["External"] = "External";
-    DereferencedIdentifierKind["InScopeDereference"] = "InScopeDereference";
-    DereferencedIdentifierKind["InScopeValue"] = "InScopeValue";
-    DereferencedIdentifierKind["Recursive"] = "Recursive";
-    DereferencedIdentifierKind["Undefined"] = "Undefined";
-})(DereferencedIdentifierKind = exports.DereferencedIdentifierKind || (exports.DereferencedIdentifierKind = {}));
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DereferencedIdentifierKind = void 0;
+var DereferencedIdentifierKind;
+(function (DereferencedIdentifierKind) {
+    DereferencedIdentifierKind["External"] = "External";
+    DereferencedIdentifierKind["InScopeDereference"] = "InScopeDereference";
+    DereferencedIdentifierKind["InScopeValue"] = "InScopeValue";
+    DereferencedIdentifierKind["Recursive"] = "Recursive";
+    DereferencedIdentifierKind["Undefined"] = "Undefined";
+})(DereferencedIdentifierKind || (exports.DereferencedIdentifierKind = DereferencedIdentifierKind = {}));
 //# sourceMappingURL=dereferencedIdentifier.js.map

package/lib/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"dereferencedIdentifier.js","sourceRoot":"","sources":["../../../../src/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifier.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAOlC,IAAY,0BAMX;AAND,WAAY,0BAA0B;IAClC,mDAAqB,CAAA;IACrB,uEAAyC,CAAA;IACzC,2DAA6B,CAAA;IAC7B,qDAAuB,CAAA;IACvB,qDAAuB,CAAA;AAC3B,CAAC,EANW,0BAA0B,GAA1B,kCAA0B,KAA1B,kCAA0B,QAMrC"}
+{"version":3,"file":"dereferencedIdentifier.js","sourceRoot":"","sources":["../../../../src/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifier.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAOlC,IAAY,0BAMX;AAND,WAAY,0BAA0B;IAClC,mDAAqB,CAAA;IACrB,uEAAyC,CAAA;IACzC,2DAA6B,CAAA;IAC7B,qDAAuB,CAAA;IACvB,qDAAuB,CAAA;AAC3B,CAAC,EANW,0BAA0B,0CAA1B,0BAA0B,QAMrC"}

package/lib/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifierUtils.d.ts

@@ -1,6 +1,6 @@
-import * as PQP from "@microsoft/powerquery-parser";
-import { NodeIdMap, TXorNode } from "@microsoft/powerquery-parser/lib/powerquery-parser/parser";
-import { ScopeById } from "../scope";
-import { TDereferencedIdentifier } from "././dereferencedIdentifier";
-import { InspectionSettings } from "../..";
-export declare function tryBuildDereferencedIdentifierPath(inspectionSettings: InspectionSettings, nodeIdMapCollection: NodeIdMap.Collection, xorNode: TXorNode, scopeById?: ScopeById): Promise<PQP.Result<ReadonlyArray<TDereferencedIdentifier>, PQP.CommonError.CommonError>>;
+import * as PQP from "@microsoft/powerquery-parser";
+import { NodeIdMap, TXorNode } from "@microsoft/powerquery-parser/lib/powerquery-parser/parser";
+import { ScopeById } from "../scope";
+import { TDereferencedIdentifier } from "././dereferencedIdentifier";
+import { InspectionSettings } from "../..";
+export declare function tryBuildDereferencedIdentifierPath(inspectionSettings: InspectionSettings, nodeIdMapCollection: NodeIdMap.Collection, xorNode: TXorNode, scopeById?: ScopeById): Promise<PQP.Result<ReadonlyArray<TDereferencedIdentifier>, PQP.CommonError.CommonError>>;

package/lib/powerquery-language-services/inspection/dereferencedIdentifier/dereferencedIdentifierUtils.js

@@ -1,222 +1,245 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryBuildDereferencedIdentifierPath = void 0;
-const PQP = require("@microsoft/powerquery-parser");
-const powerquery_parser_1 = require("@microsoft/powerquery-parser");
-const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
-const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
-const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
-const scope_1 = require("../scope");
-const dereferencedIdentifier_1 = require("././dereferencedIdentifier");
-const __1 = require("../..");
-const trace_2 = require("../../trace");
-// Recursively dereference the identifier until it reaches either:
-// - A recursive identifier which is not supported
-// - A value node
-// - An external type
-// - Undefined
-//
-// Below some examples of dereferencing local identifiers with the recursive '@' prefix.
-//
-// Evaluates to: [key1 = 42, key2 = 42]
-// let foo = 42 in [key1 = foo, key2 = @foo]
-//
-// Evaluates to: -1
-// let
-//   SomeFunction = (x as number) => -1,
-//   Record = [SomeFunction = (x as number) => if x = 42 then 42 else SomeFunction(x + 1)]
-// in
-//   Record[SomeFunction](0)
-//
-// Evaluates to: 42
-// let
-//   SomeFunction = (x as number) => -1,
-//   Record = [SomeFunction = (x as number) => if x = 42 then 42 else @SomeFunction(x + 1)]
-// in
-//   Record[SomeFunction](0)
-function tryBuildDereferencedIdentifierPath(inspectionSettings, nodeIdMapCollection, xorNode, 
-// If a map is given, then it's mutated and returned.
-// Else create a new Map instance and return that instead.
-scopeById = new Map()) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = inspectionSettings.traceManager.entry(trace_2.InspectionTraceConstant.InspectScope, tryBuildDereferencedIdentifierPath.name, inspectionSettings.initialCorrelationId, __1.TraceUtils.xorNodeDetails(xorNode));
-        const updatedSettings = Object.assign(Object.assign({}, inspectionSettings), { initialCorrelationId: trace.id });
-        try {
-            parser_1.XorNodeUtils.assertIsIdentifier(xorNode);
-            if (parser_1.XorNodeUtils.isContext(xorNode)) {
-                trace.exit({ [trace_1.TraceConstant.IsThrowing]: true });
-                throw new PQP.CommonError.InvariantError(`expected xorNode to be an identifier`, { xorNode });
-            }
-            const dereferenceResult = yield dereferenceScopeItem(updatedSettings, nodeIdMapCollection, xorNode, scopeById, xorNode);
-            trace.exit();
-            return dereferenceResult;
-        }
-        catch (caught) {
-            powerquery_parser_1.Assert.isInstanceofError(caught);
-            trace.exit();
-            return powerquery_parser_1.ResultUtils.error(PQP.CommonError.ensureCommonError(caught, inspectionSettings.locale));
-        }
-    });
-}
-exports.tryBuildDereferencedIdentifierPath = tryBuildDereferencedIdentifierPath;
-function dereferenceScopeItem(inspectionSettings, nodeIdMapCollection, identifierAstXorNode, scopeById, initialIdentifierXorNode) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = inspectionSettings.traceManager.entry(trace_2.InspectionTraceConstant.InspectScope, dereferenceScopeItem.name, inspectionSettings.initialCorrelationId, __1.TraceUtils.xorNodeDetails(identifierAstXorNode));
-        const updatedSettings = Object.assign(Object.assign({}, inspectionSettings), { initialCorrelationId: trace.id });
-        const dereferencedPath = [];
-        const initialTriedNodeScope = yield (0, scope_1.assertGetOrCreateNodeScope)(updatedSettings, nodeIdMapCollection, updatedSettings.eachScopeById, initialIdentifierXorNode.node.id, scopeById);
-        if (powerquery_parser_1.ResultUtils.isError(initialTriedNodeScope)) {
-            trace.exit({ [trace_1.TraceConstant.Result]: initialTriedNodeScope.kind });
-            return initialTriedNodeScope;
-        }
-        let currentScopeItem = initialTriedNodeScope.value.get(language_1.AstUtils.getIdentifierLiteral(initialIdentifierXorNode.node));
-        let currentIdentifierLiteral = language_1.AstUtils.getIdentifierLiteral(initialIdentifierXorNode.node);
-        if (currentScopeItem === undefined) {
-            return onIdentifierNotInScope(dereferencedPath, identifierAstXorNode, trace, updatedSettings, currentIdentifierLiteral);
-        }
-        while (currentScopeItem.kind) {
-            const currentXorNode = parser_1.NodeIdMapUtils.assertXor(nodeIdMapCollection, currentScopeItem.nodeId);
-            switch (currentScopeItem.kind) {
-                case scope_1.ScopeItemKind.LetVariable:
-                case scope_1.ScopeItemKind.RecordField:
-                case scope_1.ScopeItemKind.SectionMember:
-                    // eslint-disable-next-line no-lone-blocks
-                    {
-                        const potentialDereference = currentScopeItem.value;
-                        // Most commonly happens when a variable has yet to be defined,
-                        // for example, a context node for a RecordExpression `[let foo = 1, bar = |`
-                        if (potentialDereference === undefined) {
-                            return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
-                        }
-                        // It's referencing another identifier
-                        if (potentialDereference !== undefined &&
-                            parser_1.XorNodeUtils.isAstChecked(potentialDereference, [
-                                language_1.Ast.NodeKind.Identifier,
-                                language_1.Ast.NodeKind.IdentifierExpression,
-                            ])) {
-                            currentIdentifierLiteral = language_1.AstUtils.getIdentifierLiteral(potentialDereference.node);
-                            // If it's a non-recursive dereference
-                            if (!currentScopeItem.isRecursive) {
-                                // Generate the scope for the next dereference (if needed)
-                                // eslint-disable-next-line no-await-in-loop
-                                const triedNodeScope = yield (0, scope_1.assertGetOrCreateNodeScope)(updatedSettings, nodeIdMapCollection, updatedSettings.eachScopeById, potentialDereference.node.id, scopeById);
-                                if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
-                                    trace.exit({ [trace_1.TraceConstant.Result]: triedNodeScope.kind });
-                                    return triedNodeScope;
-                                }
-                                const nextScopeItem = triedNodeScope.value.get(currentIdentifierLiteral);
-                                if (nextScopeItem === undefined) {
-                                    return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
-                                }
-                                dereferencedPath.push({
-                                    kind: dereferencedIdentifier_1.DereferencedIdentifierKind.InScopeDereference,
-                                    xorNode: currentXorNode,
-                                    identifierLiteral: currentIdentifierLiteral,
-                                    nextScopeItem,
-                                });
-                                currentScopeItem = nextScopeItem;
-                            }
-                            // Else if it's a recursive scopeItem and we ARE looking for a recursive scopeItem,
-                            // then we're done.
-                            else if (currentIdentifierLiteral.startsWith("@")) {
-                                return onRecursiveIdentifierLiteral(dereferencedPath, currentXorNode, trace, currentIdentifierLiteral);
-                            }
-                            // Else it's a recursive scopeItem and we ARE NOT looking for a recursive scopeItem,
-                            // then look up the ancestry chain for a non-recursive scopeItem of the same name.
-                            else {
-                                const ancestoryScopeItem = findNonRecursiveScopeItemInAncestors(nodeIdMapCollection, scopeById, currentIdentifierLiteral, currentXorNode.node.id);
-                                if (ancestoryScopeItem === undefined) {
-                                    return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
-                                }
-                                currentScopeItem = ancestoryScopeItem;
-                            }
-                        }
-                        else {
-                            return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
-                        }
-                    }
-                    break;
-                case scope_1.ScopeItemKind.Each:
-                    return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
-                case scope_1.ScopeItemKind.Parameter:
-                    return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
-                case scope_1.ScopeItemKind.Undefined:
-                    dereferencedPath.push({
-                        kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Undefined,
-                        identifierLiteral: currentIdentifierLiteral,
-                        xorNode: currentXorNode,
-                    });
-                    trace.exit();
-                    return powerquery_parser_1.ResultUtils.ok(dereferencedPath);
-                default:
-                    throw powerquery_parser_1.Assert.isNever(currentScopeItem);
-            }
-        }
-        trace.exit();
-        return powerquery_parser_1.ResultUtils.ok(dereferencedPath);
-    });
-}
-// Sometimes in the scope of a lower node (e.g. a leaf node) there's a scopeItem that matches the
-// identifier literal we're looking for, but it's marked as recursive.
-// In that case we want to look up the tree to see if there's a non-recursive scopeItem of the same name further up.
-function findNonRecursiveScopeItemInAncestors(nodeIdMapCollection, scopeById, identifierLiteral, initialNodeId) {
-    var _a;
-    let currentNodeId = nodeIdMapCollection.parentIdById.get(initialNodeId);
-    while (currentNodeId) {
-        const scopeItem = (_a = scopeById.get(currentNodeId)) === null || _a === void 0 ? void 0 : _a.get(identifierLiteral);
-        if (scopeItem && !scopeItem.isRecursive) {
-            return scopeItem;
-        }
-        currentNodeId = nodeIdMapCollection.parentIdById.get(currentNodeId);
-    }
-    return undefined;
-}
-// Validates whether an unknown identifier is an externally defined type (e.g. a built-in function)
-function onIdentifierNotInScope(dereferencePath, xorNode, trace, inspectionSettings, identifierLiteral) {
-    const externalType = inspectionSettings.library.externalTypeResolver(__1.ExternalTypeUtils.valueTypeRequest(language_1.IdentifierExpressionUtils.assertNormalizedIdentifierExpression(identifierLiteral)));
-    const finalPath = externalType
-        ? {
-            kind: dereferencedIdentifier_1.DereferencedIdentifierKind.External,
-            xorNode,
-            identifierLiteral,
-            type: externalType,
-        }
-        : {
-            kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Undefined,
-            xorNode,
-            identifierLiteral,
-        };
-    dereferencePath.push(finalPath);
-    trace.exit({ [trace_1.TraceConstant.Result]: finalPath });
-    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
-}
-function onInScopeValue(dereferencePath, xorNode, trace, scopeItem) {
-    dereferencePath.push({
-        kind: dereferencedIdentifier_1.DereferencedIdentifierKind.InScopeValue,
-        xorNode,
-        scopeItem,
-    });
-    trace.exit();
-    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
-}
-function onRecursiveIdentifierLiteral(dereferencePath, xorNode, trace, identifierLiteral) {
-    dereferencePath.push({
-        kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Recursive,
-        xorNode,
-        identifierLiteral,
-    });
-    trace.exit();
-    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
-}
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryBuildDereferencedIdentifierPath = tryBuildDereferencedIdentifierPath;
+const PQP = __importStar(require("@microsoft/powerquery-parser"));
+const powerquery_parser_1 = require("@microsoft/powerquery-parser");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
+const scope_1 = require("../scope");
+const dereferencedIdentifier_1 = require("././dereferencedIdentifier");
+const __1 = require("../..");
+const trace_2 = require("../../trace");
+// Recursively dereference the identifier until it reaches either:
+// - A recursive identifier which is not supported
+// - A value node
+// - An external type
+// - Undefined
+//
+// Below some examples of dereferencing local identifiers with the recursive '@' prefix.
+//
+// Evaluates to: [key1 = 42, key2 = 42]
+// let foo = 42 in [key1 = foo, key2 = @foo]
+//
+// Evaluates to: -1
+// let
+//   SomeFunction = (x as number) => -1,
+//   Record = [SomeFunction = (x as number) => if x = 42 then 42 else SomeFunction(x + 1)]
+// in
+//   Record[SomeFunction](0)
+//
+// Evaluates to: 42
+// let
+//   SomeFunction = (x as number) => -1,
+//   Record = [SomeFunction = (x as number) => if x = 42 then 42 else @SomeFunction(x + 1)]
+// in
+//   Record[SomeFunction](0)
+async function tryBuildDereferencedIdentifierPath(inspectionSettings, nodeIdMapCollection, xorNode, 
+// If a map is given, then it's mutated and returned.
+// Else create a new Map instance and return that instead.
+scopeById = new Map()) {
+    const trace = inspectionSettings.traceManager.entry(trace_2.InspectionTraceConstant.InspectScope, tryBuildDereferencedIdentifierPath.name, inspectionSettings.initialCorrelationId, __1.TraceUtils.xorNodeDetails(xorNode));
+    const updatedSettings = {
+        ...inspectionSettings,
+        initialCorrelationId: trace.id,
+    };
+    try {
+        parser_1.XorNodeUtils.assertIsIdentifier(xorNode);
+        if (parser_1.XorNodeUtils.isContext(xorNode)) {
+            trace.exit({ [trace_1.TraceConstant.IsThrowing]: true });
+            throw new PQP.CommonError.InvariantError(`expected xorNode to be an identifier`, { xorNode });
+        }
+        const dereferenceResult = await dereferenceScopeItem(updatedSettings, nodeIdMapCollection, xorNode, scopeById, xorNode);
+        trace.exit();
+        return dereferenceResult;
+    }
+    catch (caught) {
+        powerquery_parser_1.Assert.isInstanceofError(caught);
+        trace.exit();
+        return powerquery_parser_1.ResultUtils.error(PQP.CommonError.ensureCommonError(caught, inspectionSettings.locale));
+    }
+}
+async function dereferenceScopeItem(inspectionSettings, nodeIdMapCollection, identifierAstXorNode, scopeById, initialIdentifierXorNode) {
+    const trace = inspectionSettings.traceManager.entry(trace_2.InspectionTraceConstant.InspectScope, dereferenceScopeItem.name, inspectionSettings.initialCorrelationId, __1.TraceUtils.xorNodeDetails(identifierAstXorNode));
+    const updatedSettings = {
+        ...inspectionSettings,
+        initialCorrelationId: trace.id,
+    };
+    const dereferencedPath = [];
+    const initialTriedNodeScope = await (0, scope_1.assertGetOrCreateNodeScope)(updatedSettings, nodeIdMapCollection, updatedSettings.eachScopeById, initialIdentifierXorNode.node.id, scopeById);
+    if (powerquery_parser_1.ResultUtils.isError(initialTriedNodeScope)) {
+        trace.exit({ [trace_1.TraceConstant.Result]: initialTriedNodeScope.kind });
+        return initialTriedNodeScope;
+    }
+    let currentScopeItem = initialTriedNodeScope.value.get(language_1.AstUtils.getIdentifierLiteral(initialIdentifierXorNode.node));
+    let currentIdentifierLiteral = language_1.AstUtils.getIdentifierLiteral(initialIdentifierXorNode.node);
+    if (currentScopeItem === undefined) {
+        return onIdentifierNotInScope(dereferencedPath, identifierAstXorNode, trace, updatedSettings, currentIdentifierLiteral);
+    }
+    while (currentScopeItem.kind) {
+        const currentXorNode = parser_1.NodeIdMapUtils.assertXor(nodeIdMapCollection, currentScopeItem.nodeId);
+        switch (currentScopeItem.kind) {
+            case scope_1.ScopeItemKind.LetVariable:
+            case scope_1.ScopeItemKind.RecordField:
+            case scope_1.ScopeItemKind.SectionMember:
+                {
+                    const potentialDereference = currentScopeItem.value;
+                    // Most commonly happens when a variable has yet to be defined,
+                    // for example, a context node for a RecordExpression `[let foo = 1, bar = |`
+                    if (potentialDereference === undefined) {
+                        return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
+                    }
+                    // It's referencing another identifier
+                    if (potentialDereference !== undefined &&
+                        parser_1.XorNodeUtils.isAstChecked(potentialDereference, [
+                            language_1.Ast.NodeKind.Identifier,
+                            language_1.Ast.NodeKind.IdentifierExpression,
+                        ])) {
+                        currentIdentifierLiteral = language_1.AstUtils.getIdentifierLiteral(potentialDereference.node);
+                        // If it's a non-recursive dereference
+                        if (!currentScopeItem.isRecursive) {
+                            // Generate the scope for the next dereference (if needed)
+                            // eslint-disable-next-line no-await-in-loop
+                            const triedNodeScope = await (0, scope_1.assertGetOrCreateNodeScope)(updatedSettings, nodeIdMapCollection, updatedSettings.eachScopeById, potentialDereference.node.id, scopeById);
+                            if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
+                                trace.exit({ [trace_1.TraceConstant.Result]: triedNodeScope.kind });
+                                return triedNodeScope;
+                            }
+                            const nextScopeItem = triedNodeScope.value.get(currentIdentifierLiteral);
+                            if (nextScopeItem === undefined) {
+                                return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
+                            }
+                            dereferencedPath.push({
+                                kind: dereferencedIdentifier_1.DereferencedIdentifierKind.InScopeDereference,
+                                xorNode: currentXorNode,
+                                identifierLiteral: currentIdentifierLiteral,
+                                nextScopeItem,
+                            });
+                            currentScopeItem = nextScopeItem;
+                        }
+                        // Else if it's a recursive scopeItem and we ARE looking for a recursive scopeItem,
+                        // then we're done.
+                        else if (currentIdentifierLiteral.startsWith("@")) {
+                            return onRecursiveIdentifierLiteral(dereferencedPath, currentXorNode, trace, currentIdentifierLiteral);
+                        }
+                        // Else it's a recursive scopeItem and we ARE NOT looking for a recursive scopeItem,
+                        // then look up the ancestry chain for a non-recursive scopeItem of the same name.
+                        else {
+                            const ancestoryScopeItem = findNonRecursiveScopeItemInAncestors(nodeIdMapCollection, scopeById, currentIdentifierLiteral, currentXorNode.node.id);
+                            if (ancestoryScopeItem === undefined) {
+                                return onIdentifierNotInScope(dereferencedPath, currentXorNode, trace, updatedSettings, currentIdentifierLiteral);
+                            }
+                            currentScopeItem = ancestoryScopeItem;
+                        }
+                    }
+                    else {
+                        return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
+                    }
+                }
+                break;
+            case scope_1.ScopeItemKind.Each:
+                return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
+            case scope_1.ScopeItemKind.Parameter:
+                return onInScopeValue(dereferencedPath, currentXorNode, trace, currentScopeItem);
+            case scope_1.ScopeItemKind.Undefined:
+                dereferencedPath.push({
+                    kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Undefined,
+                    identifierLiteral: currentIdentifierLiteral,
+                    xorNode: currentXorNode,
+                });
+                trace.exit();
+                return powerquery_parser_1.ResultUtils.ok(dereferencedPath);
+            default:
+                throw powerquery_parser_1.Assert.isNever(currentScopeItem);
+        }
+    }
+    trace.exit();
+    return powerquery_parser_1.ResultUtils.ok(dereferencedPath);
+}
+// Sometimes in the scope of a lower node (e.g. a leaf node) there's a scopeItem that matches the
+// identifier literal we're looking for, but it's marked as recursive.
+// In that case we want to look up the tree to see if there's a non-recursive scopeItem of the same name further up.
+function findNonRecursiveScopeItemInAncestors(nodeIdMapCollection, scopeById, identifierLiteral, initialNodeId) {
+    let currentNodeId = nodeIdMapCollection.parentIdById.get(initialNodeId);
+    while (currentNodeId) {
+        const scopeItem = scopeById.get(currentNodeId)?.get(identifierLiteral);
+        if (scopeItem && !scopeItem.isRecursive) {
+            return scopeItem;
+        }
+        currentNodeId = nodeIdMapCollection.parentIdById.get(currentNodeId);
+    }
+    return undefined;
+}
+// Validates whether an unknown identifier is an externally defined type (e.g. a built-in function)
+function onIdentifierNotInScope(dereferencePath, xorNode, trace, inspectionSettings, identifierLiteral) {
+    const externalType = inspectionSettings.library.externalTypeResolver(__1.ExternalTypeUtils.valueTypeRequest(language_1.IdentifierExpressionUtils.assertNormalizedIdentifierExpression(identifierLiteral)));
+    const finalPath = externalType
+        ? {
+            kind: dereferencedIdentifier_1.DereferencedIdentifierKind.External,
+            xorNode,
+            identifierLiteral,
+            type: externalType,
+        }
+        : {
+            kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Undefined,
+            xorNode,
+            identifierLiteral,
+        };
+    dereferencePath.push(finalPath);
+    trace.exit({ [trace_1.TraceConstant.Result]: finalPath });
+    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
+}
+function onInScopeValue(dereferencePath, xorNode, trace, scopeItem) {
+    dereferencePath.push({
+        kind: dereferencedIdentifier_1.DereferencedIdentifierKind.InScopeValue,
+        xorNode,
+        scopeItem,
+    });
+    trace.exit();
+    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
+}
+function onRecursiveIdentifierLiteral(dereferencePath, xorNode, trace, identifierLiteral) {
+    dereferencePath.push({
+        kind: dereferencedIdentifier_1.DereferencedIdentifierKind.Recursive,
+        xorNode,
+        identifierLiteral,
+    });
+    trace.exit();
+    return powerquery_parser_1.ResultUtils.ok(dereferencePath);
+}
 //# sourceMappingURL=dereferencedIdentifierUtils.js.map