@microsoft/powerquery-language-services 0.10.6 → 0.11.3

package/lib/powerquery-language-services/inspection/scope/scopeInspection.js

@@ -1,328 +1,373 @@
-"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.assertGetOrCreateNodeScope = exports.tryNodeScope = void 0;
-const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
-const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
-const powerquery_parser_1 = require("@microsoft/powerquery-parser");
-const __1 = require("../..");
-const scope_1 = require("./scope");
-const pseudoFunctionExpressionType_1 = require("../pseudoFunctionExpressionType");
-const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
-// Builds a scope for the given node.
-function tryNodeScope(settings, nodeIdMapCollection, eachScopeById, nodeId, 
-// scopeById may get mutated by adding new entries.
-scopeById) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, tryNodeScope.name, settings.initialCorrelationId);
-        const updatedSettings = Object.assign(Object.assign({}, settings), { initialCorrelationId: trace.id });
-        const result = yield powerquery_parser_1.ResultUtils.ensureResultAsync(() => __awaiter(this, void 0, void 0, function* () {
-            const ancestry = parser_1.AncestryUtils.assertAncestry(nodeIdMapCollection, nodeId);
-            if (ancestry.length === 0) {
-                return new Map();
-            }
-            yield inspectScope(updatedSettings, nodeIdMapCollection, eachScopeById, ancestry, scopeById, trace.id);
-            const result = powerquery_parser_1.MapUtils.assertGet(scopeById, nodeId, `expected nodeId in scope result`, {
-                nodeId,
-            });
-            return result;
-        }), updatedSettings.locale);
-        trace.exit();
-        return result;
-    });
-}
-exports.tryNodeScope = tryNodeScope;
-function assertGetOrCreateNodeScope(settings, nodeIdMapCollection, eachScopeById, nodeId, 
-// scopeById may get mutated by adding new entries.
-scopeById) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, assertGetOrCreateNodeScope.name, settings.initialCorrelationId);
-        const updatedSettings = Object.assign(Object.assign({}, settings), { initialCorrelationId: trace.id });
-        const nodeScope = scopeById.get(nodeId);
-        if (nodeScope !== undefined) {
-            trace.exit({ [trace_1.TraceConstant.IsThrowing]: false });
-            return powerquery_parser_1.ResultUtils.ok(nodeScope);
-        }
-        const triedNodeScope = yield tryNodeScope(updatedSettings, nodeIdMapCollection, eachScopeById, nodeId, scopeById);
-        if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
-            trace.exit({ [trace_1.TraceConstant.IsThrowing]: true });
-            throw triedNodeScope;
-        }
-        trace.exit({ [trace_1.TraceConstant.IsThrowing]: false });
-        return triedNodeScope;
-    });
-}
-exports.assertGetOrCreateNodeScope = assertGetOrCreateNodeScope;
-function inspectScope(settings, nodeIdMapCollection, eachScopeById, ancestry, 
-// scopeById may get mutated by adding new entries.
-scopeById, correlationId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectScope.name, correlationId);
-        const rootId = ancestry[0].node.id;
-        // A scope for the given ancestry has already been generated.
-        const cached = scopeById.get(rootId);
-        if (cached !== undefined) {
-            trace.exit();
-            return;
-        }
-        const state = {
-            traceManager: settings.traceManager,
-            givenScope: scopeById,
-            ancestry,
-            nodeIdMapCollection,
-            eachScopeById,
-            cancellationToken: settings.cancellationToken,
-            ancestryIndex: 0,
-        };
-        // Build up the scope through a top-down inspection.
-        const numNodes = ancestry.length;
-        for (let ancestryIndex = numNodes - 1; ancestryIndex >= 0; ancestryIndex -= 1) {
-            state.ancestryIndex = ancestryIndex;
-            const xorNode = ancestry[ancestryIndex];
-            // eslint-disable-next-line no-await-in-loop
-            yield inspectNode(state, xorNode, trace.id);
-        }
-        trace.exit();
-    });
-}
-// eslint-disable-next-line require-await
-function inspectNode(state, xorNode, correlationId) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectNode.name, correlationId, __1.TraceUtils.xorNodeDetails(xorNode));
-        (_a = state.cancellationToken) === null || _a === void 0 ? void 0 : _a.throwIfCancelled();
-        switch (xorNode.node.kind) {
-            case language_1.Ast.NodeKind.EachExpression:
-                inspectEachExpression(state, xorNode, trace.id);
-                break;
-            case language_1.Ast.NodeKind.FunctionExpression:
-                inspectFunctionExpression(state, xorNode, trace.id);
-                break;
-            case language_1.Ast.NodeKind.LetExpression:
-                inspectLetExpression(state, xorNode, trace.id);
-                break;
-            case language_1.Ast.NodeKind.RecordExpression:
-            case language_1.Ast.NodeKind.RecordLiteral:
-                inspectRecordExpressionOrRecordLiteral(state, xorNode, trace.id);
-                break;
-            case language_1.Ast.NodeKind.Section:
-                inspectSection(state, xorNode, trace.id);
-                break;
-            default:
-                localGetOrCreateNodeScope(state, xorNode.node.id, undefined, trace.id);
-        }
-        trace.exit();
-    });
-}
-function inspectEachExpression(state, eachExpr, correlationId) {
-    var _a, _b;
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectEachExpression.name, correlationId);
-    parser_1.XorNodeUtils.assertIsNodeKind(eachExpr, language_1.Ast.NodeKind.EachExpression);
-    expandChildScope(state, eachExpr, [1], [
-        [
-            "_",
-            {
-                kind: scope_1.ScopeItemKind.Each,
-                nodeId: eachExpr.node.id,
-                isRecursive: false,
-                eachExpression: eachExpr,
-                implicitParameterType: (_b = (_a = state.eachScopeById) === null || _a === void 0 ? void 0 : _a.get(eachExpr.node.id)) !== null && _b !== void 0 ? _b : language_1.Type.UnknownInstance,
-            },
-        ],
-    ], localGetOrCreateNodeScope(state, eachExpr.node.id, undefined, trace.id), trace.id);
-    trace.exit();
-}
-function inspectFunctionExpression(state, fnExpr, correlationId) {
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectFunctionExpression.name, correlationId);
-    parser_1.XorNodeUtils.assertIsNodeKind(fnExpr, language_1.Ast.NodeKind.FunctionExpression);
-    // Propegates the parent's scope.
-    const nodeScope = localGetOrCreateNodeScope(state, fnExpr.node.id, undefined, trace.id);
-    const pseudoType = (0, pseudoFunctionExpressionType_1.pseudoFunctionExpressionType)(state.nodeIdMapCollection, fnExpr);
-    const newEntries = [];
-    for (const parameter of pseudoType.parameters) {
-        const type = parameter.type
-            ? language_1.TypeUtils.primitiveTypeConstantKindFromTypeKind(parameter.type)
-            : undefined;
-        const parameterScopeItem = scopeItemFactoryForParameter(parameter, type);
-        for (const scopeKey of language_1.IdentifierUtils.getAllowedIdentifiers(parameter.name.literal)) {
-            newEntries.push([scopeKey, parameterScopeItem]);
-        }
-    }
-    expandChildScope(state, fnExpr, [3], newEntries, nodeScope, trace.id);
-    trace.exit();
-}
-function inspectLetExpression(state, letExpr, correlationId) {
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectLetExpression.name, correlationId);
-    parser_1.XorNodeUtils.assertIsNodeKind(letExpr, language_1.Ast.NodeKind.LetExpression);
-    // Propegates the parent's scope.
-    const nodeScope = localGetOrCreateNodeScope(state, letExpr.node.id, undefined, trace.id);
-    const keyValuePairs = parser_1.NodeIdMapIterator.iterLetExpression(state.nodeIdMapCollection, letExpr);
-    inspectKeyValuePairs(state, nodeScope, keyValuePairs, { allowRecursive: true }, scopeItemFactoryForLetVariable, trace.id);
-    // Places the assignments from the 'let' into LetExpression.expression
-    const newEntries = scopeItemFactoryForKeyValuePairs(keyValuePairs, -1, { allowRecursive: true }, scopeItemFactoryForLetVariable);
-    expandChildScope(state, letExpr, [3], newEntries, nodeScope, trace.id);
-    trace.exit();
-}
-function inspectRecordExpressionOrRecordLiteral(state, record, correlationId) {
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectRecordExpressionOrRecordLiteral.name, correlationId);
-    parser_1.XorNodeUtils.assertIsRecord(record);
-    // Propegates the parent's scope.
-    const nodeScope = localGetOrCreateNodeScope(state, record.node.id, undefined, trace.id);
-    const keyValuePairs = parser_1.NodeIdMapIterator.iterRecord(state.nodeIdMapCollection, record);
-    inspectKeyValuePairs(state, nodeScope, keyValuePairs, {
-        allowGeneralizedIdentifier: true,
-        allowRecursive: true,
-    }, scopeItemFactoryForRecordMember, trace.id);
-    trace.exit();
-}
-function inspectSection(state, section, correlationId) {
-    var _a;
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectSection.name, correlationId);
-    parser_1.XorNodeUtils.assertIsNodeKind(section, language_1.Ast.NodeKind.Section);
-    const keyValuePairs = parser_1.NodeIdMapIterator.iterSection(state.nodeIdMapCollection, section);
-    for (const kvp of keyValuePairs) {
-        (_a = state.cancellationToken) === null || _a === void 0 ? void 0 : _a.throwIfCancelled();
-        if (kvp.value === undefined) {
-            continue;
-        }
-        const newScopeItems = scopeItemFactoryForKeyValuePairs(keyValuePairs, kvp.key.id, { allowRecursive: true }, scopeItemFactoryForSectionMember);
-        if (newScopeItems.length !== 0) {
-            expandScope(state, kvp.value, newScopeItems, new Map(), trace.id);
-        }
-    }
-    trace.exit();
-}
-// Expands the scope on the value part of the key value pair.
-function inspectKeyValuePairs(state, parentScope, keyValuePairs, getAllowedIdentifiersOptions, scopeItemFactory, correlationId) {
-    var _a;
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectKeyValuePairs.name, correlationId);
-    for (const kvp of keyValuePairs) {
-        (_a = state.cancellationToken) === null || _a === void 0 ? void 0 : _a.throwIfCancelled();
-        if (kvp.value === undefined) {
-            continue;
-        }
-        const newScopeItems = scopeItemFactoryForKeyValuePairs(keyValuePairs, kvp.key.id, getAllowedIdentifiersOptions, scopeItemFactory);
-        if (newScopeItems.length !== 0) {
-            expandScope(state, kvp.value, newScopeItems, parentScope, trace.id);
-        }
-    }
-    trace.exit();
-}
-function expandScope(state, xorNode, newEntries, defaultScope, correlationId) {
-    const nodeScope = localGetOrCreateNodeScope(state, xorNode.node.id, defaultScope, correlationId);
-    for (const [key, value] of newEntries) {
-        nodeScope.set(key, value);
-    }
-}
-function expandChildScope(state, parent, childAttributeIds, newEntries, defaultScope, correlationId) {
-    const nodeIdMapCollection = state.nodeIdMapCollection;
-    const parentId = parent.node.id;
-    // TODO: optimize this
-    for (const attributeId of childAttributeIds) {
-        const child = parser_1.NodeIdMapUtils.nthChildXor(nodeIdMapCollection, parentId, attributeId);
-        if (child !== undefined) {
-            expandScope(state, child, newEntries, defaultScope, correlationId);
-        }
-    }
-}
-// Any operation done on a scope should first invoke `scopeFor` for data integrity.
-function localGetOrCreateNodeScope(state, nodeId, defaultScope, correlationId) {
-    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, localGetOrCreateNodeScope.name, correlationId, { nodeId });
-    // If scopeFor has already been called then there should be a nodeId in the givenScope.
-    const givenScope = state.givenScope.get(nodeId);
-    if (givenScope !== undefined) {
-        trace.exit({ [trace_1.TraceConstant.Result]: "givenScope cache hit" });
-        return givenScope;
-    }
-    if (defaultScope !== undefined) {
-        const shallowCopy = new Map(defaultScope.entries());
-        state.givenScope.set(nodeId, shallowCopy);
-        trace.exit({ [trace_1.TraceConstant.Result]: "defaultScope entry" });
-        return shallowCopy;
-    }
-    const xorNode = parser_1.NodeIdMapUtils.assertXor(state.nodeIdMapCollection, nodeId);
-    if ([language_1.Ast.NodeKind.FieldProjection, language_1.Ast.NodeKind.FieldSelector].includes(xorNode.node.kind)) {
-        trace.exit({ [trace_1.TraceConstant.Result]: "field projection or selector - empty scope" });
-        const newScope = new Map();
-        state.givenScope.set(nodeId, newScope);
-        return newScope;
-    }
-    // Default to a parent's scope if the node has a parent.
-    const parent = parser_1.NodeIdMapUtils.parentXor(state.nodeIdMapCollection, nodeId);
-    if (parent !== undefined) {
-        const parentNodeId = parent.node.id;
-        const parentGivenScope = state.givenScope.get(parentNodeId);
-        if (parentGivenScope !== undefined) {
-            const shallowCopy = new Map(parentGivenScope.entries());
-            state.givenScope.set(nodeId, shallowCopy);
-            trace.exit({ [trace_1.TraceConstant.Result]: "parent givenScope hit" });
-            return parentGivenScope;
-        }
-    }
-    // The node has no parent or it hasn't been visited.
-    const newScope = new Map();
-    state.givenScope.set(nodeId, newScope);
-    trace.exit({ [trace_1.TraceConstant.Result]: "set new entry" });
-    return newScope;
-}
-function scopeItemFactoryForKeyValuePairs(keyValuePairs, ancestorKeyNodeId, getAllowedIdentifiersOptions, scopeItemFactory) {
-    const result = [];
-    for (const kvp of keyValuePairs.filter((keyValuePair) => keyValuePair.value !== undefined)) {
-        const isRecursive = ancestorKeyNodeId === kvp.key.id;
-        for (const key of language_1.IdentifierUtils.getAllowedIdentifiers(kvp.key.literal, getAllowedIdentifiersOptions)) {
-            if (!isRecursive || key.includes("@")) {
-                result.push([key, scopeItemFactory(kvp, isRecursive)]);
-            }
-        }
-    }
-    return result;
-}
-function scopeItemFactoryForLetVariable(keyValuePair, isRecursive) {
-    return {
-        kind: scope_1.ScopeItemKind.LetVariable,
-        nodeId: keyValuePair.source.node.id,
-        isRecursive,
-        key: keyValuePair.key,
-        value: keyValuePair.value,
-    };
-}
-function scopeItemFactoryForParameter(parameter, type) {
-    return {
-        kind: scope_1.ScopeItemKind.Parameter,
-        nodeId: parameter.id,
-        isRecursive: false,
-        name: parameter.name,
-        isOptional: parameter.isOptional,
-        isNullable: parameter.isNullable,
-        type,
-    };
-}
-function scopeItemFactoryForRecordMember(keyValuePair, isRecursive) {
-    return {
-        kind: scope_1.ScopeItemKind.RecordField,
-        nodeId: keyValuePair.source.node.id,
-        isRecursive,
-        key: keyValuePair.key,
-        value: keyValuePair.value,
-    };
-}
-function scopeItemFactoryForSectionMember(keyValuePair, isRecursive) {
-    return {
-        kind: scope_1.ScopeItemKind.SectionMember,
-        nodeId: keyValuePair.source.node.id,
-        isRecursive,
-        key: keyValuePair.key,
-        value: keyValuePair.value,
-    };
-}
+"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.tryNodeScope = tryNodeScope;
+exports.assertGetOrCreateNodeScope = assertGetOrCreateNodeScope;
+const PQP = __importStar(require("@microsoft/powerquery-parser"));
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
+const powerquery_parser_1 = require("@microsoft/powerquery-parser");
+const __1 = require("../..");
+const scope_1 = require("./scope");
+const pseudoFunctionExpressionType_1 = require("../pseudoFunctionExpressionType");
+const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
+// Builds a scope for the given node.
+async function tryNodeScope(settings, nodeIdMapCollection, eachScopeById, nodeId, 
+// scopeById may get mutated by adding new entries.
+scopeById) {
+    const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, tryNodeScope.name, settings.initialCorrelationId);
+    const updatedSettings = {
+        ...settings,
+        initialCorrelationId: trace.id,
+    };
+    const result = await powerquery_parser_1.ResultUtils.ensureResultAsync(async () => {
+        const ancestry = parser_1.AncestryUtils.assertAncestry(nodeIdMapCollection, nodeId);
+        if (ancestry.length === 0) {
+            throw new PQP.CommonError.InvariantError(`expected ancestry to have at least one node`, { nodeId });
+        }
+        await inspectScope(updatedSettings, nodeIdMapCollection, eachScopeById, ancestry, scopeById, trace.id);
+        const result = powerquery_parser_1.MapUtils.assertGet(scopeById, nodeId, `expected nodeId in scope result`, {
+            nodeId,
+        });
+        return result;
+    }, updatedSettings.locale);
+    trace.exit();
+    return result;
+}
+async function assertGetOrCreateNodeScope(settings, nodeIdMapCollection, eachScopeById, nodeId, 
+// scopeById may get mutated by adding new entries.
+scopeById) {
+    const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, assertGetOrCreateNodeScope.name, settings.initialCorrelationId);
+    const updatedSettings = {
+        ...settings,
+        initialCorrelationId: trace.id,
+    };
+    const nodeScope = scopeById.get(nodeId);
+    if (nodeScope !== undefined) {
+        trace.exit({ [trace_1.TraceConstant.IsThrowing]: false });
+        return powerquery_parser_1.ResultUtils.ok(nodeScope);
+    }
+    const triedNodeScope = await tryNodeScope(updatedSettings, nodeIdMapCollection, eachScopeById, nodeId, scopeById);
+    if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
+        trace.exit({ [trace_1.TraceConstant.IsThrowing]: true });
+        throw triedNodeScope;
+    }
+    trace.exit({ [trace_1.TraceConstant.IsThrowing]: false });
+    return triedNodeScope;
+}
+// The only function that should directly mutate `ScopeInspectionState.scopeById`.
+// It attempts to reuse the inherited scope instance whenever:
+//  1. there's no `newEntries`,
+//  2. the node is not a FieldSelector or FieldProjection (which have special scoping rules)
+//
+// For scenario (1) we take a shallow copy of the parent's scope, then merge in the new entries.
+// This means the `newEntries` take precedence over the inherited scope.
+//
+// For scenario (2) we only inherit `EachScopeItem`s from the parent scope.
+function assignScopeForNodeId(state, nodeId, inheritedScope, newEntries, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, assignScopeForNodeId.name, correlationId, { nodeId });
+    // If a scope has already been generated for this nodeId, return it.
+    // This can happen as a parent might have assigned a scope to its child already,
+    // e.g. LetExpression assigns scope to its expression.
+    const existingNodeScope = state.scopeById.get(nodeId);
+    if (existingNodeScope !== undefined) {
+        trace.exit({ [trace_1.TraceConstant.Result]: "cache hit" });
+        return existingNodeScope;
+    }
+    // Unique case for root node.
+    if (inheritedScope === undefined) {
+        const nodeScope = {
+            createdForNodeId: nodeId,
+            scopeItemByKey: new Map(newEntries ?? []),
+        };
+        state.scopeById.set(nodeId, nodeScope);
+        trace.exit({ [trace_1.TraceConstant.Result]: "new root scope" });
+        return nodeScope;
+    }
+    const xorNode = parser_1.NodeIdMapUtils.assertXor(state.nodeIdMapCollection, nodeId);
+    // We can't actually inherit everything if node is a FieldSelector or FieldProjection,
+    // so we create a new scope that only includes allowed items.
+    if ([language_1.Ast.NodeKind.FieldProjection, language_1.Ast.NodeKind.FieldSelector].includes(xorNode.node.kind)) {
+        const inheritedEachScopeItemEntries = [
+            ...inheritedScope.scopeItemByKey.entries(),
+        ].filter(([_key, scopeItem]) => scopeItem.kind === scope_1.ScopeItemKind.Each);
+        const nodeScope = {
+            createdForNodeId: nodeId,
+            scopeItemByKey: new Map([...inheritedEachScopeItemEntries, ...(newEntries ?? [])]),
+        };
+        state.scopeById.set(nodeId, nodeScope);
+        trace.exit({ [trace_1.TraceConstant.Result]: "inherited filtered scope" });
+        return nodeScope;
+    }
+    // Else if there are no new entries we can simply inherit the scope.
+    else if (!newEntries) {
+        state.scopeById.set(nodeId, inheritedScope);
+        trace.exit({ [trace_1.TraceConstant.Result]: "inherited scope" });
+        return inheritedScope;
+    }
+    // Else there are new entries so we create a new scope that merges the inherited scope with the new entries.
+    else {
+        const nodeScope = {
+            createdForNodeId: nodeId,
+            scopeItemByKey: new Map([...inheritedScope.scopeItemByKey.entries(), ...newEntries]),
+        };
+        state.scopeById.set(nodeId, nodeScope);
+        trace.exit({ [trace_1.TraceConstant.Result]: "created new scope" });
+        return nodeScope;
+    }
+}
+function getParentScope(state, nodeId) {
+    const parentNodeId = state.nodeIdMapCollection.parentIdById.get(nodeId);
+    if (parentNodeId === undefined) {
+        return undefined;
+    }
+    return state.scopeById.get(parentNodeId);
+}
+async function inspectScope(settings, nodeIdMapCollection, eachScopeById, ancestry, 
+// scopeById may get mutated by adding new entries.
+scopeById, correlationId) {
+    const trace = settings.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectScope.name, correlationId);
+    const rootId = ancestry[0].node.id;
+    // A scope for the given ancestry has already been generated.
+    const cached = scopeById.get(rootId);
+    if (cached !== undefined) {
+        trace.exit();
+        return;
+    }
+    const state = {
+        traceManager: settings.traceManager,
+        scopeById,
+        ancestry,
+        nodeIdMapCollection,
+        eachScopeById,
+        cancellationToken: settings.cancellationToken,
+        ancestryIndex: 0,
+    };
+    // Build up the scope through a top-down inspection.
+    const numNodes = ancestry.length;
+    for (let ancestryIndex = numNodes - 1; ancestryIndex >= 0; ancestryIndex -= 1) {
+        state.ancestryIndex = ancestryIndex;
+        const xorNode = ancestry[ancestryIndex];
+        // eslint-disable-next-line no-await-in-loop
+        await inspectNode(state, xorNode, trace.id);
+    }
+    trace.exit();
+}
+// eslint-disable-next-line require-await
+async function inspectNode(state, xorNode, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectNode.name, correlationId, __1.TraceUtils.xorNodeDetails(xorNode));
+    state.cancellationToken?.throwIfCancelled();
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (xorNode.node.kind) {
+        case language_1.Ast.NodeKind.EachExpression:
+            inspectEachExpression(state, xorNode, trace.id);
+            break;
+        case language_1.Ast.NodeKind.FunctionExpression:
+            inspectFunctionExpression(state, xorNode, trace.id);
+            break;
+        case language_1.Ast.NodeKind.LetExpression:
+            inspectLetExpression(state, xorNode, trace.id);
+            break;
+        case language_1.Ast.NodeKind.RecordExpression:
+        case language_1.Ast.NodeKind.RecordLiteral:
+            inspectRecordExpressionOrRecordLiteral(state, xorNode, trace.id);
+            break;
+        case language_1.Ast.NodeKind.Section:
+            inspectSection(state, xorNode, trace.id);
+            break;
+        default:
+            assignScopeForNodeId(state, xorNode.node.id, getParentScope(state, xorNode.node.id), 
+            /* newEntries */ undefined, trace.id);
+    }
+    trace.exit();
+}
+function inspectEachExpression(state, eachExpr, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectEachExpression.name, correlationId);
+    parser_1.XorNodeUtils.assertIsNodeKind(eachExpr, language_1.Ast.NodeKind.EachExpression);
+    // Generate the scope for the EachExpression
+    const nodeScope = assignScopeForNodeId(state, eachExpr.node.id, getParentScope(state, eachExpr.node.id), 
+    /* newEntries */ undefined, trace.id);
+    // Propegate the scope to the paired expression (if one exists)
+    const expression = parser_1.NodeIdMapUtils.nthChildXor(state.nodeIdMapCollection, eachExpr.node.id, 1);
+    if (expression !== undefined) {
+        assignScopeForNodeId(state, expression.node.id, nodeScope, 
+        // Append the implicit "_" parameter for the 'each' expression.
+        [
+            [
+                "_",
+                {
+                    kind: scope_1.ScopeItemKind.Each,
+                    nodeId: eachExpr.node.id,
+                    isRecursive: false,
+                    eachExpression: eachExpr,
+                    implicitParameterType: state.eachScopeById?.get(eachExpr.node.id) ?? language_1.Type.UnknownInstance,
+                },
+            ],
+        ], trace.id);
+    }
+    trace.exit();
+}
+function inspectFunctionExpression(state, fnExpr, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectFunctionExpression.name, correlationId);
+    parser_1.XorNodeUtils.assertIsNodeKind(fnExpr, language_1.Ast.NodeKind.FunctionExpression);
+    // Creates the NodeScope for the FunctionExpression.
+    const nodeScope = assignScopeForNodeId(state, fnExpr.node.id, getParentScope(state, fnExpr.node.id), 
+    /* newEntries */ undefined, trace.id);
+    // Build up a list of new scope items derived from the function's parameters.
+    const newEntries = [];
+    const pseudoType = (0, pseudoFunctionExpressionType_1.pseudoFunctionExpressionType)(state.nodeIdMapCollection, fnExpr);
+    for (const parameter of pseudoType.parameters) {
+        const type = parameter.type
+            ? language_1.TypeUtils.primitiveTypeConstantKindFromTypeKind(parameter.type)
+            : undefined;
+        const parameterScopeItem = scopeItemFactoryForParameter(parameter, type);
+        for (const scopeKey of language_1.IdentifierUtils.getAllowedIdentifiers(parameter.name.literal)) {
+            newEntries.push([scopeKey, parameterScopeItem]);
+        }
+    }
+    // Propagate the FunctionExpression's scope to its body.
+    const functionExpressionBody = parser_1.NodeIdMapUtils.nthChildXor(state.nodeIdMapCollection, fnExpr.node.id, 3);
+    if (functionExpressionBody !== undefined) {
+        assignScopeForNodeId(state, functionExpressionBody.node.id, nodeScope, newEntries, trace.id);
+    }
+    trace.exit();
+}
+function inspectLetExpression(state, letExpr, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectLetExpression.name, correlationId);
+    parser_1.XorNodeUtils.assertIsNodeKind(letExpr, language_1.Ast.NodeKind.LetExpression);
+    // Creates the NodeScope for the LetExpression.
+    const nodeScope = assignScopeForNodeId(state, letExpr.node.id, getParentScope(state, letExpr.node.id), 
+    /* newEntries */ undefined, trace.id);
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterLetExpression(state.nodeIdMapCollection, letExpr);
+    inspectKeyValuePairs(state, nodeScope, keyValuePairs, { allowRecursive: true }, scopeItemFactoryForLetVariable, trace.id);
+    // Places the assignments from the 'let' into LetExpression.expression
+    const newEntries = scopeItemFactoryForKeyValuePairs(keyValuePairs, -1, { allowRecursive: true }, scopeItemFactoryForLetVariable);
+    const expression = parser_1.NodeIdMapUtils.nthChildXor(state.nodeIdMapCollection, letExpr.node.id, 3);
+    if (expression !== undefined) {
+        assignScopeForNodeId(state, expression.node.id, nodeScope, newEntries, trace.id);
+    }
+    trace.exit();
+}
+function inspectRecordExpressionOrRecordLiteral(state, record, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectRecordExpressionOrRecordLiteral.name, correlationId);
+    parser_1.XorNodeUtils.assertIsRecord(record);
+    // Creates the NodeScope for the record.
+    const nodeScope = assignScopeForNodeId(state, record.node.id, getParentScope(state, record.node.id), 
+    /* newEntries */ undefined, trace.id);
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterRecord(state.nodeIdMapCollection, record);
+    inspectKeyValuePairs(state, nodeScope, keyValuePairs, {
+        allowGeneralizedIdentifier: true,
+        allowRecursive: true,
+    }, scopeItemFactoryForRecordMember, trace.id);
+    trace.exit();
+}
+function inspectSection(state, section, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectSection.name, correlationId);
+    parser_1.XorNodeUtils.assertIsNodeKind(section, language_1.Ast.NodeKind.Section);
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterSection(state.nodeIdMapCollection, section);
+    for (const kvp of keyValuePairs) {
+        state.cancellationToken?.throwIfCancelled();
+        if (kvp.value === undefined) {
+            continue;
+        }
+        assignScopeForNodeId(state, kvp.value.node.id, getParentScope(state, kvp.value.node.id), scopeItemFactoryForKeyValuePairs(keyValuePairs, kvp.key.id, { allowRecursive: true }, scopeItemFactoryForSectionMember), trace.id);
+    }
+    trace.exit();
+}
+// Expands the scope on the value part of the key value pair.
+function inspectKeyValuePairs(state, inheritedScope, keyValuePairs, getAllowedIdentifiersOptions, scopeItemFactory, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectKeyValuePairs.name, correlationId);
+    for (const kvp of keyValuePairs) {
+        state.cancellationToken?.throwIfCancelled();
+        if (kvp.value === undefined) {
+            continue;
+        }
+        assignScopeForNodeId(state, kvp.value.node.id, inheritedScope, scopeItemFactoryForKeyValuePairs(keyValuePairs, kvp.key.id, getAllowedIdentifiersOptions, scopeItemFactory), trace.id);
+    }
+    trace.exit();
+}
+function scopeItemFactoryForKeyValuePairs(keyValuePairs, keyNodeId, getAllowedIdentifiersOptions, scopeItemFactory) {
+    const result = [];
+    for (const kvp of keyValuePairs.filter((keyValuePair) => keyValuePair.value !== undefined)) {
+        const isRecursive = keyNodeId === kvp.key.id;
+        for (const key of language_1.IdentifierUtils.getAllowedIdentifiers(kvp.key.literal, getAllowedIdentifiersOptions)) {
+            if (!isRecursive || key.includes("@")) {
+                result.push([key, scopeItemFactory(kvp, isRecursive)]);
+            }
+        }
+    }
+    return result;
+}
+function scopeItemFactoryForLetVariable(keyValuePair, isRecursive) {
+    return {
+        kind: scope_1.ScopeItemKind.LetVariable,
+        nodeId: keyValuePair.source.node.id,
+        isRecursive,
+        key: keyValuePair.key,
+        value: keyValuePair.value,
+    };
+}
+function scopeItemFactoryForParameter(parameter, type) {
+    return {
+        kind: scope_1.ScopeItemKind.Parameter,
+        nodeId: parameter.id,
+        isRecursive: false,
+        name: parameter.name,
+        isOptional: parameter.isOptional,
+        isNullable: parameter.isNullable,
+        type,
+    };
+}
+function scopeItemFactoryForRecordMember(keyValuePair, isRecursive) {
+    return {
+        kind: scope_1.ScopeItemKind.RecordField,
+        nodeId: keyValuePair.source.node.id,
+        isRecursive,
+        key: keyValuePair.key,
+        value: keyValuePair.value,
+    };
+}
+function scopeItemFactoryForSectionMember(keyValuePair, isRecursive) {
+    return {
+        kind: scope_1.ScopeItemKind.SectionMember,
+        nodeId: keyValuePair.source.node.id,
+        isRecursive,
+        key: keyValuePair.key,
+        value: keyValuePair.value,
+    };
+}
 //# sourceMappingURL=scopeInspection.js.map