@microsoft/powerquery-language-services 0.2.17 → 0.3.1

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

@@ -1,74 +1,59 @@
 "use strict";
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
+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.maybeDereferencedIdentifier = exports.assertGetOrCreateNodeScope = exports.tryNodeScope = void 0;
-var parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
-var powerquery_parser_1 = require("@microsoft/powerquery-parser");
-var language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
-var __1 = require("../..");
-var pseudoFunctionExpressionType_1 = require("../pseudoFunctionExpressionType");
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const powerquery_parser_1 = require("@microsoft/powerquery-parser");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
+const __1 = require("../..");
+const pseudoFunctionExpressionType_1 = require("../pseudoFunctionExpressionType");
 // Builds a scope for the given node.
 function tryNodeScope(settings, nodeIdMapCollection, nodeId, 
 // scopeById may get mutated by adding new entries.
 scopeById) {
-    var trace = settings.traceManager.entry("Scope" /* Scope */, tryNodeScope.name);
-    var result = powerquery_parser_1.ResultUtils.ensureResult(settings.locale, function () {
-        var ancestry = parser_1.AncestryUtils.assertGetAncestry(nodeIdMapCollection, nodeId);
-        if (ancestry.length === 0) {
-            return new Map();
-        }
-        var inspected = inspectScope(settings, nodeIdMapCollection, ancestry, scopeById);
-        return powerquery_parser_1.Assert.asDefined(inspected.get(nodeId), "expected nodeId in scope result", { nodeId: nodeId });
+    return __awaiter(this, void 0, void 0, function* () {
+        const trace = settings.traceManager.entry("Scope" /* Scope */, tryNodeScope.name);
+        const result = yield powerquery_parser_1.ResultUtils.ensureResultAsync(settings.locale, () => __awaiter(this, void 0, void 0, function* () {
+            const ancestry = parser_1.AncestryUtils.assertGetAncestry(nodeIdMapCollection, nodeId);
+            if (ancestry.length === 0) {
+                return new Map();
+            }
+            const inspected = yield inspectScope(settings, nodeIdMapCollection, ancestry, scopeById);
+            return powerquery_parser_1.Assert.asDefined(inspected.get(nodeId), `expected nodeId in scope result`, { nodeId });
+        }));
+        trace.exit();
+        return result;
     });
-    trace.exit();
-    return result;
 }
 exports.tryNodeScope = tryNodeScope;
 function assertGetOrCreateNodeScope(settings, nodeIdMapCollection, nodeId, 
 // scopeById may get mutated by adding new entries.
 scopeById) {
-    var _a, _b, _c;
-    var trace = settings.traceManager.entry("Scope" /* Scope */, assertGetOrCreateNodeScope.name);
-    var maybeScope = scopeById.get(nodeId);
-    if (maybeScope !== undefined) {
-        trace.exit((_a = {}, _a["IsThrowing" /* IsThrowing */] = false, _a));
-        return powerquery_parser_1.ResultUtils.boxOk(maybeScope);
-    }
-    var triedNodeScope = tryNodeScope(settings, nodeIdMapCollection, nodeId, scopeById);
-    if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
-        trace.exit((_b = {}, _b["IsThrowing" /* IsThrowing */] = true, _b));
-        throw triedNodeScope;
-    }
-    trace.exit((_c = {}, _c["IsThrowing" /* IsThrowing */] = false, _c));
-    return triedNodeScope;
+    return __awaiter(this, void 0, void 0, function* () {
+        const trace = settings.traceManager.entry("Scope" /* Scope */, assertGetOrCreateNodeScope.name);
+        const maybeScope = scopeById.get(nodeId);
+        if (maybeScope !== undefined) {
+            trace.exit({ ["IsThrowing" /* IsThrowing */]: false });
+            return powerquery_parser_1.ResultUtils.boxOk(maybeScope);
+        }
+        const triedNodeScope = yield tryNodeScope(settings, nodeIdMapCollection, nodeId, scopeById);
+        if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
+            trace.exit({ ["IsThrowing" /* IsThrowing */]: true });
+            throw triedNodeScope;
+        }
+        trace.exit({ ["IsThrowing" /* IsThrowing */]: false });
+        return triedNodeScope;
+    });
 }
 exports.assertGetOrCreateNodeScope = assertGetOrCreateNodeScope;
 // Recusrive deference of the identifier until it reaches the value node.
@@ -76,132 +61,138 @@ exports.assertGetOrCreateNodeScope = assertGetOrCreateNodeScope;
 function maybeDereferencedIdentifier(settings, nodeIdMapCollection, xorNode, 
 // If a map is given, then it's mutated and returned.
 // Else create a new Map instance and return that instead.
-scopeById) {
-    var _a, _b, _c, _d;
-    if (scopeById === void 0) { scopeById = new Map(); }
-    var trace = settings.traceManager.entry("Scope" /* Scope */, maybeDereferencedIdentifier.name, __1.TraceUtils.createXorNodeDetails(xorNode));
-    parser_1.XorNodeUtils.assertIsIdentifier(xorNode);
-    if (parser_1.XorNodeUtils.isContextXor(xorNode)) {
-        trace.exit((_a = {}, _a["Result" /* Result */] = undefined, _a));
-        return powerquery_parser_1.ResultUtils.boxOk(undefined);
-    }
-    var identifier = xorNode.node;
-    var identifierLiteral;
-    var isIdentifierRecurisve;
-    switch (identifier.kind) {
-        case "Identifier" /* Identifier */:
-            identifierLiteral = identifier.literal;
-            isIdentifierRecurisve = false;
-            break;
-        case "IdentifierExpression" /* IdentifierExpression */:
-            identifierLiteral = identifier.identifier.literal;
-            isIdentifierRecurisve = identifier.maybeInclusiveConstant !== undefined;
-            break;
-        default:
-            throw powerquery_parser_1.Assert.isNever(identifier);
-    }
-    var triedNodeScope = assertGetOrCreateNodeScope(settings, nodeIdMapCollection, xorNode.node.id, scopeById);
-    if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
-        trace.exit((_b = {}, _b["Result" /* Result */] = triedNodeScope.kind, _b));
-        return triedNodeScope;
-    }
-    var nodeScope = triedNodeScope.value;
-    var maybeScopeItem = nodeScope.get(identifierLiteral);
-    if (
-    // If the identifier couldn't be found in the generated scope,
-    // then either the scope generation is incorrect or it's an external identifier.
-    (maybeScopeItem === null || maybeScopeItem === void 0 ? void 0 : maybeScopeItem.isRecursive) !== isIdentifierRecurisve) {
-        trace.exit((_c = {}, _c["Result" /* Result */] = undefined, _c));
-        return powerquery_parser_1.ResultUtils.boxOk(undefined);
-    }
-    var scopeItem = maybeScopeItem;
-    var maybeNextXorNode;
-    switch (scopeItem.kind) {
-        case "Each" /* Each */:
-        case "Parameter" /* Parameter */:
-        case "Undefined" /* Undefined */:
-            break;
-        case "LetVariable" /* LetVariable */:
-        case "RecordField" /* RecordField */:
-            maybeNextXorNode = scopeItem.maybeValue;
-            break;
-        case "SectionMember" /* SectionMember */:
-            maybeNextXorNode = scopeItem.maybeValue;
-            break;
-        default:
-            throw powerquery_parser_1.Assert.isNever(scopeItem);
-    }
-    var result;
-    if (maybeNextXorNode === undefined) {
-        result = powerquery_parser_1.ResultUtils.boxOk(xorNode);
-    }
-    else if (parser_1.XorNodeUtils.isContextXor(maybeNextXorNode) ||
-        (maybeNextXorNode.node.kind !== "Identifier" /* Identifier */ &&
-            maybeNextXorNode.node.kind !== "IdentifierExpression" /* IdentifierExpression */)) {
-        result = powerquery_parser_1.ResultUtils.boxOk(xorNode);
-    }
-    else {
-        result = maybeDereferencedIdentifier(settings, nodeIdMapCollection, maybeNextXorNode, scopeById);
-    }
-    trace.exit((_d = {}, _d["Result" /* Result */] = result.kind, _d));
-    return result;
+scopeById = new Map()) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const trace = settings.traceManager.entry("Scope" /* Scope */, maybeDereferencedIdentifier.name, __1.TraceUtils.createXorNodeDetails(xorNode));
+        parser_1.XorNodeUtils.assertIsIdentifier(xorNode);
+        if (parser_1.XorNodeUtils.isContextXor(xorNode)) {
+            trace.exit({ ["Result" /* Result */]: undefined });
+            return powerquery_parser_1.ResultUtils.boxOk(undefined);
+        }
+        const identifier = xorNode.node;
+        let identifierLiteral;
+        let isIdentifierRecurisve;
+        switch (identifier.kind) {
+            case "Identifier" /* Identifier */:
+                identifierLiteral = identifier.literal;
+                isIdentifierRecurisve = false;
+                break;
+            case "IdentifierExpression" /* IdentifierExpression */:
+                identifierLiteral = identifier.identifier.literal;
+                isIdentifierRecurisve = identifier.maybeInclusiveConstant !== undefined;
+                break;
+            default:
+                throw powerquery_parser_1.Assert.isNever(identifier);
+        }
+        const triedNodeScope = yield assertGetOrCreateNodeScope(settings, nodeIdMapCollection, xorNode.node.id, scopeById);
+        if (powerquery_parser_1.ResultUtils.isError(triedNodeScope)) {
+            trace.exit({ ["Result" /* Result */]: triedNodeScope.kind });
+            return triedNodeScope;
+        }
+        const nodeScope = triedNodeScope.value;
+        const maybeScopeItem = nodeScope.get(identifierLiteral);
+        if (
+        // If the identifier couldn't be found in the generated scope,
+        // then either the scope generation is incorrect or it's an external identifier.
+        (maybeScopeItem === null || maybeScopeItem === void 0 ? void 0 : maybeScopeItem.isRecursive) !== isIdentifierRecurisve) {
+            trace.exit({ ["Result" /* Result */]: undefined });
+            return powerquery_parser_1.ResultUtils.boxOk(undefined);
+        }
+        const scopeItem = maybeScopeItem;
+        let maybeNextXorNode;
+        switch (scopeItem.kind) {
+            case "Each" /* Each */:
+            case "Parameter" /* Parameter */:
+            case "Undefined" /* Undefined */:
+                break;
+            case "LetVariable" /* LetVariable */:
+            case "RecordField" /* RecordField */:
+                maybeNextXorNode = scopeItem.maybeValue;
+                break;
+            case "SectionMember" /* SectionMember */:
+                maybeNextXorNode = scopeItem.maybeValue;
+                break;
+            default:
+                throw powerquery_parser_1.Assert.isNever(scopeItem);
+        }
+        let result;
+        if (maybeNextXorNode === undefined) {
+            result = Promise.resolve(powerquery_parser_1.ResultUtils.boxOk(xorNode));
+        }
+        else if (parser_1.XorNodeUtils.isContextXor(maybeNextXorNode) ||
+            (maybeNextXorNode.node.kind !== "Identifier" /* Identifier */ &&
+                maybeNextXorNode.node.kind !== "IdentifierExpression" /* IdentifierExpression */)) {
+            result = Promise.resolve(powerquery_parser_1.ResultUtils.boxOk(xorNode));
+        }
+        else {
+            result = maybeDereferencedIdentifier(settings, nodeIdMapCollection, maybeNextXorNode, scopeById);
+        }
+        trace.exit();
+        return result;
+    });
 }
 exports.maybeDereferencedIdentifier = maybeDereferencedIdentifier;
 function inspectScope(settings, nodeIdMapCollection, ancestry, 
 // scopeById may get mutated by adding new entries.
 scopeById) {
-    var trace = settings.traceManager.entry("Scope" /* Scope */, inspectScope.name);
-    var rootId = ancestry[0].node.id;
-    // A scope for the given ancestry has already been generated.
-    var maybeCached = scopeById.get(rootId);
-    if (maybeCached !== undefined) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const trace = settings.traceManager.entry("Scope" /* Scope */, inspectScope.name);
+        const rootId = ancestry[0].node.id;
+        // A scope for the given ancestry has already been generated.
+        const maybeCached = scopeById.get(rootId);
+        if (maybeCached !== undefined) {
+            trace.exit();
+            return scopeById;
+        }
+        // Store the delta between the given scope and what's found in a temporary map.
+        // This will prevent mutation in the given map if an error is thrown.
+        const scopeChanges = new Map();
+        const state = {
+            traceManager: settings.traceManager,
+            givenScope: scopeById,
+            deltaScope: scopeChanges,
+            ancestry,
+            nodeIdMapCollection,
+            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.exit();
-        return scopeById;
-    }
-    // Store the delta between the given scope and what's found in a temporary map.
-    // This will prevent mutation in the given map if an error is thrown.
-    var scopeChanges = new Map();
-    var state = {
-        traceManager: settings.traceManager,
-        givenScope: scopeById,
-        deltaScope: scopeChanges,
-        ancestry: ancestry,
-        nodeIdMapCollection: nodeIdMapCollection,
-        ancestryIndex: 0,
-    };
-    // Build up the scope through a top-down inspection.
-    var numNodes = ancestry.length;
-    for (var ancestryIndex = numNodes - 1; ancestryIndex >= 0; ancestryIndex -= 1) {
-        state.ancestryIndex = ancestryIndex;
-        var xorNode = ancestry[ancestryIndex];
-        inspectNode(state, xorNode);
-    }
-    trace.exit();
-    return state.deltaScope;
+        return state.deltaScope;
+    });
 }
+// eslint-disable-next-line require-await
 function inspectNode(state, xorNode) {
-    var trace = state.traceManager.entry("Scope" /* Scope */, inspectNode.name, __1.TraceUtils.createXorNodeDetails(xorNode));
-    switch (xorNode.node.kind) {
-        case "EachExpression" /* EachExpression */:
-            inspectEachExpression(state, xorNode);
-            break;
-        case "FunctionExpression" /* FunctionExpression */:
-            inspectFunctionExpression(state, xorNode);
-            break;
-        case "LetExpression" /* LetExpression */:
-            inspectLetExpression(state, xorNode);
-            break;
-        case "RecordExpression" /* RecordExpression */:
-        case "RecordLiteral" /* RecordLiteral */:
-            inspectRecordExpressionOrRecordLiteral(state, xorNode);
-            break;
-        case "Section" /* Section */:
-            inspectSection(state, xorNode);
-            break;
-        default:
-            localGetOrCreateNodeScope(state, xorNode.node.id, undefined);
-    }
-    trace.exit();
+    return __awaiter(this, void 0, void 0, function* () {
+        const trace = state.traceManager.entry("Scope" /* Scope */, inspectNode.name, __1.TraceUtils.createXorNodeDetails(xorNode));
+        switch (xorNode.node.kind) {
+            case "EachExpression" /* EachExpression */:
+                inspectEachExpression(state, xorNode);
+                break;
+            case "FunctionExpression" /* FunctionExpression */:
+                inspectFunctionExpression(state, xorNode);
+                break;
+            case "LetExpression" /* LetExpression */:
+                inspectLetExpression(state, xorNode);
+                break;
+            case "RecordExpression" /* RecordExpression */:
+            case "RecordLiteral" /* RecordLiteral */:
+                inspectRecordExpressionOrRecordLiteral(state, xorNode);
+                break;
+            case "Section" /* Section */:
+                inspectSection(state, xorNode);
+                break;
+            default:
+                localGetOrCreateNodeScope(state, xorNode.node.id, undefined);
+        }
+        trace.exit();
+    });
 }
 function inspectEachExpression(state, eachExpr) {
     parser_1.XorNodeUtils.assertIsNodeKind(eachExpr, "EachExpression" /* EachExpression */);
@@ -220,183 +211,147 @@ function inspectEachExpression(state, eachExpr) {
 function inspectFunctionExpression(state, fnExpr) {
     parser_1.XorNodeUtils.assertIsNodeKind(fnExpr, "FunctionExpression" /* FunctionExpression */);
     // Propegates the parent's scope.
-    var nodeScope = localGetOrCreateNodeScope(state, fnExpr.node.id, undefined);
-    var pseudoType = (0, pseudoFunctionExpressionType_1.pseudoFunctionExpressionType)(state.nodeIdMapCollection, fnExpr);
-    var newEntries = pseudoType.parameters.map(function (parameter) {
-        return [
-            parameter.name.literal,
-            {
-                kind: "Parameter" /* Parameter */,
-                id: parameter.id,
-                isRecursive: false,
-                name: parameter.name,
-                isOptional: parameter.isOptional,
-                isNullable: parameter.isNullable,
-                maybeType: parameter.maybeType !== undefined
-                    ? language_1.TypeUtils.maybePrimitiveTypeConstantKindFromTypeKind(parameter.maybeType)
-                    : undefined,
-            },
-        ];
-    });
+    const nodeScope = localGetOrCreateNodeScope(state, fnExpr.node.id, undefined);
+    const pseudoType = (0, pseudoFunctionExpressionType_1.pseudoFunctionExpressionType)(state.nodeIdMapCollection, fnExpr);
+    const newEntries = pseudoType.parameters.map((parameter) => [
+        parameter.name.literal,
+        {
+            kind: "Parameter" /* Parameter */,
+            id: parameter.id,
+            isRecursive: false,
+            name: parameter.name,
+            isOptional: parameter.isOptional,
+            isNullable: parameter.isNullable,
+            maybeType: parameter.maybeType !== undefined
+                ? language_1.TypeUtils.maybePrimitiveTypeConstantKindFromTypeKind(parameter.maybeType)
+                : undefined,
+        },
+    ]);
     expandChildScope(state, fnExpr, [3], newEntries, nodeScope);
 }
 function inspectLetExpression(state, letExpr) {
     parser_1.XorNodeUtils.assertIsNodeKind(letExpr, "LetExpression" /* LetExpression */);
     // Propegates the parent's scope.
-    var nodeScope = localGetOrCreateNodeScope(state, letExpr.node.id, undefined);
-    var keyValuePairs = parser_1.NodeIdMapIterator.iterLetExpression(state.nodeIdMapCollection, letExpr);
+    const nodeScope = localGetOrCreateNodeScope(state, letExpr.node.id, undefined);
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterLetExpression(state.nodeIdMapCollection, letExpr);
     inspectKeyValuePairs(state, nodeScope, keyValuePairs, createLetVariableScopeItem);
     // Places the assignments from the 'let' into LetExpression.expression
-    var newEntries = scopeItemsFromKeyValuePairs(keyValuePairs, -1, createLetVariableScopeItem);
+    const newEntries = scopeItemsFromKeyValuePairs(keyValuePairs, -1, createLetVariableScopeItem);
     expandChildScope(state, letExpr, [3], newEntries, nodeScope);
 }
 function inspectRecordExpressionOrRecordLiteral(state, record) {
     parser_1.XorNodeUtils.assertIsRecord(record);
     // Propegates the parent's scope.
-    var nodeScope = localGetOrCreateNodeScope(state, record.node.id, undefined);
-    var keyValuePairs = parser_1.NodeIdMapIterator.iterRecord(state.nodeIdMapCollection, record);
+    const nodeScope = localGetOrCreateNodeScope(state, record.node.id, undefined);
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterRecord(state.nodeIdMapCollection, record);
     inspectKeyValuePairs(state, nodeScope, keyValuePairs, createRecordMemberScopeItem);
 }
 function inspectSection(state, section) {
-    var e_1, _a;
     parser_1.XorNodeUtils.assertIsNodeKind(section, "Section" /* Section */);
-    var keyValuePairs = parser_1.NodeIdMapIterator.iterSection(state.nodeIdMapCollection, section);
-    try {
-        for (var keyValuePairs_1 = __values(keyValuePairs), keyValuePairs_1_1 = keyValuePairs_1.next(); !keyValuePairs_1_1.done; keyValuePairs_1_1 = keyValuePairs_1.next()) {
-            var kvp = keyValuePairs_1_1.value;
-            if (kvp.maybeValue === undefined) {
-                continue;
-            }
-            var newScopeItems = scopeItemsFromKeyValuePairs(keyValuePairs, kvp.key.id, createSectionMemberScopeItem);
-            if (newScopeItems.length !== 0) {
-                expandScope(state, kvp.maybeValue, newScopeItems, new Map());
-            }
+    const keyValuePairs = parser_1.NodeIdMapIterator.iterSection(state.nodeIdMapCollection, section);
+    for (const kvp of keyValuePairs) {
+        if (kvp.maybeValue === undefined) {
+            continue;
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (keyValuePairs_1_1 && !keyValuePairs_1_1.done && (_a = keyValuePairs_1.return)) _a.call(keyValuePairs_1);
+        const newScopeItems = scopeItemsFromKeyValuePairs(keyValuePairs, kvp.key.id, createSectionMemberScopeItem);
+        if (newScopeItems.length !== 0) {
+            expandScope(state, kvp.maybeValue, newScopeItems, new Map());
         }
-        finally { if (e_1) throw e_1.error; }
     }
 }
-// Expands the scope of the value portion for each key value pair.
+// Expands the scope on the value part of the key value pair.
 function inspectKeyValuePairs(state, parentScope, keyValuePairs, createFn) {
-    var e_2, _a;
-    try {
-        for (var keyValuePairs_2 = __values(keyValuePairs), keyValuePairs_2_1 = keyValuePairs_2.next(); !keyValuePairs_2_1.done; keyValuePairs_2_1 = keyValuePairs_2.next()) {
-            var kvp = keyValuePairs_2_1.value;
-            if (kvp.maybeValue === undefined) {
-                continue;
-            }
-            var newScopeItems = scopeItemsFromKeyValuePairs(keyValuePairs, kvp.key.id, createFn);
-            if (newScopeItems.length !== 0) {
-                expandScope(state, kvp.maybeValue, newScopeItems, parentScope);
-            }
+    for (const kvp of keyValuePairs) {
+        if (kvp.maybeValue === undefined) {
+            continue;
         }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (keyValuePairs_2_1 && !keyValuePairs_2_1.done && (_a = keyValuePairs_2.return)) _a.call(keyValuePairs_2);
+        const newScopeItems = scopeItemsFromKeyValuePairs(keyValuePairs, kvp.key.id, createFn);
+        if (newScopeItems.length !== 0) {
+            expandScope(state, kvp.maybeValue, newScopeItems, parentScope);
         }
-        finally { if (e_2) throw e_2.error; }
     }
 }
 function expandScope(state, xorNode, newEntries, maybeDefaultScope) {
-    var e_3, _a;
-    var nodeScope = localGetOrCreateNodeScope(state, xorNode.node.id, maybeDefaultScope);
-    try {
-        for (var newEntries_1 = __values(newEntries), newEntries_1_1 = newEntries_1.next(); !newEntries_1_1.done; newEntries_1_1 = newEntries_1.next()) {
-            var _b = __read(newEntries_1_1.value, 2), key = _b[0], value = _b[1];
-            nodeScope.set(key, value);
-        }
-    }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-    finally {
-        try {
-            if (newEntries_1_1 && !newEntries_1_1.done && (_a = newEntries_1.return)) _a.call(newEntries_1);
-        }
-        finally { if (e_3) throw e_3.error; }
+    const nodeScope = localGetOrCreateNodeScope(state, xorNode.node.id, maybeDefaultScope);
+    for (const [key, value] of newEntries) {
+        nodeScope.set(value.isRecursive ? `@${key}` : key, value);
     }
 }
 function expandChildScope(state, parent, childAttributeIds, newEntries, maybeDefaultScope) {
-    var e_4, _a;
-    var nodeIdMapCollection = state.nodeIdMapCollection;
-    var parentId = parent.node.id;
-    try {
-        // TODO: optimize this
-        for (var childAttributeIds_1 = __values(childAttributeIds), childAttributeIds_1_1 = childAttributeIds_1.next(); !childAttributeIds_1_1.done; childAttributeIds_1_1 = childAttributeIds_1.next()) {
-            var attributeId = childAttributeIds_1_1.value;
-            var maybeChild = parser_1.NodeIdMapUtils.maybeNthChild(nodeIdMapCollection, parentId, attributeId);
-            if (maybeChild !== undefined) {
-                expandScope(state, maybeChild, newEntries, maybeDefaultScope);
-            }
+    const nodeIdMapCollection = state.nodeIdMapCollection;
+    const parentId = parent.node.id;
+    // TODO: optimize this
+    for (const attributeId of childAttributeIds) {
+        const maybeChild = parser_1.NodeIdMapUtils.maybeNthChild(nodeIdMapCollection, parentId, attributeId);
+        if (maybeChild !== undefined) {
+            expandScope(state, maybeChild, newEntries, maybeDefaultScope);
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-    finally {
-        try {
-            if (childAttributeIds_1_1 && !childAttributeIds_1_1.done && (_a = childAttributeIds_1.return)) _a.call(childAttributeIds_1);
-        }
-        finally { if (e_4) throw e_4.error; }
-    }
 }
 // Any operation done on a scope should first invoke `scopeFor` for data integrity.
 function localGetOrCreateNodeScope(state, nodeId, maybeDefaultScope) {
+    const trace = state.traceManager.entry("Scope" /* Scope */, localGetOrCreateNodeScope.name, {
+        nodeId,
+    });
     // If scopeFor has already been called then there should be a nodeId in the deltaScope.
-    var maybeDeltaScope = state.deltaScope.get(nodeId);
+    const maybeDeltaScope = state.deltaScope.get(nodeId);
     if (maybeDeltaScope !== undefined) {
+        trace.exit({ ["Result" /* Result */]: "deltaScope cache hit" });
         return maybeDeltaScope;
     }
     // If given a scope with an existing value then assume it's valid.
     // Cache and return.
-    var maybeGivenScope = state.givenScope.get(nodeId);
+    const maybeGivenScope = state.givenScope.get(nodeId);
     if (maybeGivenScope !== undefined) {
-        var shallowCopy = new Map(maybeGivenScope.entries());
+        const shallowCopy = new Map(maybeGivenScope.entries());
         state.deltaScope.set(nodeId, shallowCopy);
+        trace.exit({ ["Result" /* Result */]: "givenScope cache hit" });
         return shallowCopy;
     }
     if (maybeDefaultScope !== undefined) {
-        var shallowCopy = new Map(maybeDefaultScope.entries());
+        const shallowCopy = new Map(maybeDefaultScope.entries());
         state.deltaScope.set(nodeId, shallowCopy);
+        trace.exit({ ["Result" /* Result */]: "defaultScope entry" });
         return shallowCopy;
     }
     // Default to a parent's scope if the node has a parent.
-    var maybeParent = parser_1.NodeIdMapUtils.maybeParentXor(state.nodeIdMapCollection, nodeId);
+    const maybeParent = parser_1.NodeIdMapUtils.maybeParentXor(state.nodeIdMapCollection, nodeId);
     if (maybeParent !== undefined) {
-        var parentNodeId = maybeParent.node.id;
-        var maybeParentDeltaScope = state.deltaScope.get(parentNodeId);
+        const parentNodeId = maybeParent.node.id;
+        const maybeParentDeltaScope = state.deltaScope.get(parentNodeId);
         if (maybeParentDeltaScope !== undefined) {
-            var shallowCopy = new Map(maybeParentDeltaScope.entries());
+            const shallowCopy = new Map(maybeParentDeltaScope.entries());
             state.deltaScope.set(nodeId, shallowCopy);
+            trace.exit({ ["Result" /* Result */]: "parent deltaScope hit" });
             return shallowCopy;
         }
-        var maybeParentGivenScope = state.givenScope.get(parentNodeId);
+        const maybeParentGivenScope = state.givenScope.get(parentNodeId);
         if (maybeParentGivenScope !== undefined) {
-            var shallowCopy = new Map(maybeParentGivenScope.entries());
+            const shallowCopy = new Map(maybeParentGivenScope.entries());
             state.deltaScope.set(nodeId, shallowCopy);
+            trace.exit({ ["Result" /* Result */]: "parent givenScope hit" });
             return shallowCopy;
         }
     }
     // The node has no parent or it hasn't been visited.
-    var newScope = new Map();
+    const newScope = new Map();
     state.deltaScope.set(nodeId, newScope);
+    trace.exit({ ["Result" /* Result */]: "set new entry" });
     return newScope;
 }
 function scopeItemsFromKeyValuePairs(keyValuePairs, ancestorKeyNodeId, createFn) {
     return keyValuePairs
-        .filter(function (keyValuePair) { return keyValuePair.maybeValue !== undefined; })
-        .map(function (keyValuePair) {
-        return [keyValuePair.keyLiteral, createFn(keyValuePair, ancestorKeyNodeId === keyValuePair.key.id)];
-    });
+        .filter((keyValuePair) => keyValuePair.maybeValue !== undefined)
+        .map((keyValuePair) => [
+        keyValuePair.keyLiteral,
+        createFn(keyValuePair, ancestorKeyNodeId === keyValuePair.key.id),
+    ]);
 }
 function createSectionMemberScopeItem(keyValuePair, isRecursive) {
     return {
         kind: "SectionMember" /* SectionMember */,
         id: keyValuePair.source.node.id,
-        isRecursive: isRecursive,
+        isRecursive,
         key: keyValuePair.key,
         maybeValue: keyValuePair.maybeValue,
     };
@@ -405,7 +360,7 @@ function createLetVariableScopeItem(keyValuePair, isRecursive) {
     return {
         kind: "LetVariable" /* LetVariable */,
         id: keyValuePair.source.node.id,
-        isRecursive: isRecursive,
+        isRecursive,
         key: keyValuePair.key,
         maybeValue: keyValuePair.maybeValue,
     };
@@ -414,7 +369,7 @@ function createRecordMemberScopeItem(keyValuePair, isRecursive) {
     return {
         kind: "RecordField" /* RecordField */,
         id: keyValuePair.source.node.id,
-        isRecursive: isRecursive,
+        isRecursive,
         key: keyValuePair.key,
         maybeValue: keyValuePair.maybeValue,
     };