@microsoft/powerquery-language-services 0.10.5 → 0.11.1

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

@@ -1,328 +1,314 @@
-"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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNodeScope = tryNodeScope;
+exports.assertGetOrCreateNodeScope = assertGetOrCreateNodeScope;
+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) {
+            return new Map();
+        }
+        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;
+}
+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,
+        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
+        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:
+            localGetOrCreateNodeScope(state, xorNode.node.id, 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);
+    expandChildScope(state, eachExpr, [1], [
+        [
+            "_",
+            {
+                kind: scope_1.ScopeItemKind.Each,
+                nodeId: eachExpr.node.id,
+                isRecursive: false,
+                eachExpression: eachExpr,
+                implicitParameterType: state.eachScopeById?.get(eachExpr.node.id) ?? 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) {
+    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;
+        }
+        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) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectScope, inspectKeyValuePairs.name, correlationId);
+    for (const kvp of keyValuePairs) {
+        state.cancellationToken?.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;
+    }
+    // Default to a parent's scope if the node has a parent.
+    // Special handling is needed for FieldProjection/FieldSelector which should only copy the EachExpression scope.
+    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 xorNode = parser_1.NodeIdMapUtils.assertXor(state.nodeIdMapCollection, nodeId);
+            let shallowCopy;
+            if ([language_1.Ast.NodeKind.FieldProjection, language_1.Ast.NodeKind.FieldSelector].includes(xorNode.node.kind)) {
+                shallowCopy = powerquery_parser_1.MapUtils.filter(parentGivenScope, (_key, value) => value.kind === scope_1.ScopeItemKind.Each);
+            }
+            else {
+                shallowCopy = new Map(parentGivenScope.entries());
+            }
+            state.givenScope.set(nodeId, shallowCopy);
+            trace.exit({ [trace_1.TraceConstant.Result]: "parent givenScope hit" });
+            return shallowCopy;
+        }
+    }
+    // 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,
+    };
+}
 //# sourceMappingURL=scopeInspection.js.map