@microsoft/powerquery-language-services 0.10.6 → 0.11.1

package/lib/powerquery-language-services/inspection/type/inspectType/inspectTypeTBinOpExpression.js

@@ -1,293 +1,327 @@
-"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.partialLookupKey = exports.lookupKey = exports.PartialLookup = exports.Lookup = exports.inspectTypeTBinOpExpression = void 0;
-const PQP = require("@microsoft/powerquery-parser");
-const powerquery_parser_1 = require("@microsoft/powerquery-parser");
-const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
-const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
-const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
-const __1 = require("../../..");
-const common_1 = require("./common");
-function inspectTypeTBinOpExpression(state, xorNode, correlationId) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectType, inspectTypeTBinOpExpression.name, correlationId, __1.TraceUtils.xorNodeDetails(xorNode));
-        (_a = state.cancellationToken) === null || _a === void 0 ? void 0 : _a.throwIfCancelled();
-        powerquery_parser_1.Assert.isTrue(language_1.AstUtils.isTBinOpExpressionKind(xorNode.node.kind), `xorNode isn't a TBinOpExpression`, {
-            nodeId: xorNode.node.id,
-            nodeKind: xorNode.node.kind,
-        });
-        const parentId = xorNode.node.id;
-        const children = parser_1.NodeIdMapIterator.assertIterChildrenXor(state.nodeIdMapCollection, parentId);
-        const left = children[0];
-        const operatorKind = children[1] === undefined || parser_1.XorNodeUtils.isContext(children[1])
-            ? undefined
-            : children[1].node.constantKind;
-        const right = children[2];
-        let result;
-        // ''
-        if (left === undefined) {
-            result = language_1.Type.UnknownInstance;
-        }
-        // '1'
-        else if (operatorKind === undefined) {
-            result = yield (0, common_1.inspectXor)(state, left, trace.id);
-        }
-        // '1 +'
-        else if (right === undefined || parser_1.XorNodeUtils.isContext(right)) {
-            const leftType = yield (0, common_1.inspectXor)(state, left, trace.id);
-            const key = partialLookupKey(leftType.kind, operatorKind);
-            const allowedTypeKinds = exports.PartialLookup.get(key);
-            if (allowedTypeKinds === undefined) {
-                result = language_1.Type.NoneInstance;
-            }
-            else if (allowedTypeKinds.size === 1) {
-                result = language_1.TypeUtils.primitiveType(leftType.isNullable, allowedTypeKinds.values().next().value);
-            }
-            else {
-                const unionedTypePairs = [];
-                for (const kind of allowedTypeKinds.values()) {
-                    unionedTypePairs.push({
-                        kind,
-                        extendedKind: undefined,
-                        isNullable: true,
-                    });
-                }
-                result = language_1.TypeUtils.anyUnion(unionedTypePairs, state.traceManager, trace.id);
-            }
-        }
-        // '1 + 1'
-        else {
-            const leftType = yield (0, common_1.inspectXor)(state, left, trace.id);
-            const rightType = yield (0, common_1.inspectXor)(state, right, trace.id);
-            const key = lookupKey(leftType.kind, operatorKind, rightType.kind);
-            const resultTypeKind = exports.Lookup.get(key);
-            if (resultTypeKind === undefined) {
-                result = language_1.Type.NoneInstance;
-            }
-            else if (operatorKind === language_1.Constant.ArithmeticOperator.And &&
-                (resultTypeKind === language_1.Type.TypeKind.Record || resultTypeKind === language_1.Type.TypeKind.Table)) {
-                result = inspectRecordOrTableUnion(leftType, rightType);
-            }
-            else {
-                result = language_1.TypeUtils.primitiveType(leftType.isNullable || rightType.isNullable, resultTypeKind);
-            }
-        }
-        trace.exit({ [trace_1.TraceConstant.Result]: __1.TraceUtils.typeDetails(result) });
-        return result;
-    });
-}
-exports.inspectTypeTBinOpExpression = inspectTypeTBinOpExpression;
-function inspectRecordOrTableUnion(leftType, rightType) {
-    if (leftType.kind !== rightType.kind) {
-        const details = {
-            leftTypeKind: leftType.kind,
-            rightTypeKind: rightType.kind,
-        };
-        throw new PQP.CommonError.InvariantError(`leftType.kind !== rightType.kind`, details);
-    }
-    // '[] & []' or '#table() & #table()'
-    else if (leftType.extendedKind === undefined && rightType.extendedKind === undefined) {
-        return language_1.TypeUtils.primitiveType(leftType.isNullable || rightType.isNullable, leftType.kind);
-    }
-    // '[key=value] & []' or '#table(...) & #table()`
-    // '[] & [key=value]' or `#table() & #table(...)`
-    else if ((leftType.extendedKind !== undefined && rightType.extendedKind === undefined) ||
-        (leftType.extendedKind === undefined && rightType.extendedKind !== undefined)) {
-        // The 'rightType as (...)' isn't needed, except TypeScript's checker isn't smart enough to know it.
-        const extendedKind = leftType.extendedKind !== undefined ? leftType : rightType;
-        return Object.assign(Object.assign({}, extendedKind), { isOpen: true });
-    }
-    // '[foo=value] & [bar=value] or #table(...) & #table(...)'
-    else if ((leftType === null || leftType === void 0 ? void 0 : leftType.extendedKind) === (rightType === null || rightType === void 0 ? void 0 : rightType.extendedKind)) {
-        // The cast should be safe since the first if statement tests their the same kind,
-        // and the above checks if they're the same extended kind.
-        if (language_1.TypeUtils.isRecord(leftType)) {
-            return unionRecordFields([leftType, rightType]);
-        }
-        else {
-            return unionTableFields([leftType, rightType]);
-        }
-    }
-    else {
-        throw new powerquery_parser_1.CommonError.InvariantError(`this should never be reached`);
-    }
-}
-function unionRecordFields([leftType, rightType]) {
-    const combinedFields = new Map(leftType.fields);
-    for (const [key, value] of rightType.fields.entries()) {
-        combinedFields.set(key, value);
-    }
-    return Object.assign(Object.assign({}, leftType), { fields: combinedFields, isNullable: leftType.isNullable && rightType.isNullable, isOpen: leftType.isOpen || rightType.isOpen });
-}
-function unionTableFields([leftType, rightType]) {
-    const combinedFields = new PQP.OrderedMap([...leftType.fields]);
-    for (const [key, value] of rightType.fields.entries()) {
-        combinedFields.set(key, value);
-    }
-    return Object.assign(Object.assign({}, leftType), { fields: combinedFields, isNullable: leftType.isNullable && rightType.isNullable, isOpen: leftType.isOpen || rightType.isOpen });
-}
-// Keys: <first operand> <operator> <second operand>
-// Values: the resulting type of the binary operation expression.
-// Eg. '1 > 3' -> Type.TypeKind.Number
-exports.Lookup = new Map([
-    ...lookupsForNullEquality(),
-    ...lookupsForRelational(language_1.Type.TypeKind.Null),
-    ...lookupsForEquality(language_1.Type.TypeKind.Null),
-    ...lookupsForRelational(language_1.Type.TypeKind.Logical),
-    ...lookupsForEquality(language_1.Type.TypeKind.Logical),
-    ...lookupsForLogical(language_1.Type.TypeKind.Logical),
-    ...lookupsForRelational(language_1.Type.TypeKind.Number),
-    ...lookupsForEquality(language_1.Type.TypeKind.Number),
-    ...lookupsForArithmetic(language_1.Type.TypeKind.Number),
-    ...lookupsForRelational(language_1.Type.TypeKind.Time),
-    ...lookupsForEquality(language_1.Type.TypeKind.Time),
-    ...lookupsForClockKind(language_1.Type.TypeKind.Time),
-    [lookupKey(language_1.Type.TypeKind.Date, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Time), language_1.Type.TypeKind.DateTime],
-    ...lookupsForRelational(language_1.Type.TypeKind.Date),
-    ...lookupsForEquality(language_1.Type.TypeKind.Date),
-    ...lookupsForClockKind(language_1.Type.TypeKind.Date),
-    [lookupKey(language_1.Type.TypeKind.Date, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Time), language_1.Type.TypeKind.DateTime],
-    ...lookupsForRelational(language_1.Type.TypeKind.DateTime),
-    ...lookupsForEquality(language_1.Type.TypeKind.DateTime),
-    ...lookupsForClockKind(language_1.Type.TypeKind.DateTime),
-    ...lookupsForRelational(language_1.Type.TypeKind.DateTimeZone),
-    ...lookupsForEquality(language_1.Type.TypeKind.DateTimeZone),
-    ...lookupsForClockKind(language_1.Type.TypeKind.DateTimeZone),
-    ...lookupsForRelational(language_1.Type.TypeKind.Duration),
-    ...lookupsForEquality(language_1.Type.TypeKind.Duration),
-    [
-        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Addition, language_1.Type.TypeKind.Duration),
-        language_1.Type.TypeKind.Duration,
-    ],
-    [
-        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Subtraction, language_1.Type.TypeKind.Duration),
-        language_1.Type.TypeKind.Duration,
-    ],
-    [
-        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Multiplication, language_1.Type.TypeKind.Number),
-        language_1.Type.TypeKind.Duration,
-    ],
-    [
-        lookupKey(language_1.Type.TypeKind.Number, language_1.Constant.ArithmeticOperator.Multiplication, language_1.Type.TypeKind.Duration),
-        language_1.Type.TypeKind.Duration,
-    ],
-    [
-        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Division, language_1.Type.TypeKind.Number),
-        language_1.Type.TypeKind.Duration,
-    ],
-    ...lookupsForRelational(language_1.Type.TypeKind.Text),
-    ...lookupsForEquality(language_1.Type.TypeKind.Text),
-    [lookupKey(language_1.Type.TypeKind.Text, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Text), language_1.Type.TypeKind.Text],
-    ...lookupsForRelational(language_1.Type.TypeKind.Binary),
-    ...lookupsForEquality(language_1.Type.TypeKind.Binary),
-    ...lookupsForEquality(language_1.Type.TypeKind.List),
-    [lookupKey(language_1.Type.TypeKind.List, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.List), language_1.Type.TypeKind.List],
-    ...lookupsForEquality(language_1.Type.TypeKind.Record),
-    [lookupKey(language_1.Type.TypeKind.Record, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Record), language_1.Type.TypeKind.Record],
-    ...lookupsForEquality(language_1.Type.TypeKind.Table),
-    [lookupKey(language_1.Type.TypeKind.Table, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Table), language_1.Type.TypeKind.Table],
-]);
-// Keys: <first operand> <operator>
-// Values: a set of types that are allowed for <second operand>
-// Eg. '1 + ' ->
-exports.PartialLookup = new Map(
-// Grab the keys
-[...exports.Lookup.keys()]
-    .reduce((binaryExpressionPartialLookup, key, _currentIndex, _array) => {
-    const lastDeliminatorIndex = key.lastIndexOf(",");
-    // Grab '<first operand> , <operator>'.
-    const partialKey = key.slice(0, lastDeliminatorIndex);
-    // Grab '<second operand>'.
-    const potentialNewValue = key.slice(lastDeliminatorIndex + 1);
-    // Add the potentialNewValue if it's a new Type.
-    const values = binaryExpressionPartialLookup.get(partialKey);
-    // First occurance of '<first operand> , <operator>'
-    if (values === undefined) {
-        binaryExpressionPartialLookup.set(partialKey, new Set([potentialNewValue]));
-    }
-    else {
-        values.add(potentialNewValue);
-    }
-    return binaryExpressionPartialLookup;
-}, new Map())
-    .entries());
-function lookupKey(leftTypeKind, operatorKind, rightTypeKind) {
-    return `${leftTypeKind},${operatorKind},${rightTypeKind}`;
-}
-exports.lookupKey = lookupKey;
-function partialLookupKey(leftTypeKind, operatorKind) {
-    return `${leftTypeKind},${operatorKind}`;
-}
-exports.partialLookupKey = partialLookupKey;
-function lookupsForRelational(typeKind) {
-    return [
-        [lookupKey(typeKind, language_1.Constant.RelationalOperator.GreaterThan, typeKind), language_1.Type.TypeKind.Logical],
-        [lookupKey(typeKind, language_1.Constant.RelationalOperator.GreaterThanEqualTo, typeKind), language_1.Type.TypeKind.Logical],
-        [lookupKey(typeKind, language_1.Constant.RelationalOperator.LessThan, typeKind), language_1.Type.TypeKind.Logical],
-        [lookupKey(typeKind, language_1.Constant.RelationalOperator.LessThanEqualTo, typeKind), language_1.Type.TypeKind.Logical],
-    ];
-}
-function lookupsForEquality(typeKind) {
-    return [
-        [lookupKey(typeKind, language_1.Constant.EqualityOperator.EqualTo, typeKind), language_1.Type.TypeKind.Logical],
-        [lookupKey(typeKind, language_1.Constant.EqualityOperator.NotEqualTo, typeKind), language_1.Type.TypeKind.Logical],
-    ];
-}
-function lookupsForNullEquality() {
-    const results = [];
-    for (const typeKind of language_1.Type.TypeKinds) {
-        results.push([
-            lookupKey(typeKind, language_1.Constant.EqualityOperator.EqualTo, language_1.Type.TypeKind.Null),
-            language_1.Type.TypeKind.Logical,
-        ]);
-        results.push([
-            lookupKey(typeKind, language_1.Constant.EqualityOperator.NotEqualTo, language_1.Type.TypeKind.Null),
-            language_1.Type.TypeKind.Logical,
-        ]);
-        results.push([
-            lookupKey(language_1.Type.TypeKind.Null, language_1.Constant.EqualityOperator.EqualTo, typeKind),
-            language_1.Type.TypeKind.Logical,
-        ]);
-        results.push([
-            lookupKey(language_1.Type.TypeKind.Null, language_1.Constant.EqualityOperator.NotEqualTo, typeKind),
-            language_1.Type.TypeKind.Logical,
-        ]);
-    }
-    return results;
-}
-// Note: does not include the and <'&'> Constant.
-function lookupsForArithmetic(typeKind) {
-    return [
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Addition, typeKind), typeKind],
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Division, typeKind), typeKind],
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Multiplication, typeKind), typeKind],
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, typeKind), typeKind],
-    ];
-}
-function lookupsForLogical(typeKind) {
-    return [
-        [lookupKey(typeKind, language_1.Constant.LogicalOperator.And, typeKind), typeKind],
-        [lookupKey(typeKind, language_1.Constant.LogicalOperator.Or, typeKind), typeKind],
-    ];
-}
-function lookupsForClockKind(typeKind) {
-    return [
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Addition, language_1.Type.TypeKind.Duration), typeKind],
-        [lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Addition, typeKind), typeKind],
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, language_1.Type.TypeKind.Duration), typeKind],
-        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, typeKind), language_1.Type.TypeKind.Duration],
-    ];
-}
+"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.PartialLookup = exports.Lookup = void 0;
+exports.inspectTypeTBinOpExpression = inspectTypeTBinOpExpression;
+exports.lookupKey = lookupKey;
+exports.partialLookupKey = partialLookupKey;
+const PQP = __importStar(require("@microsoft/powerquery-parser"));
+const powerquery_parser_1 = require("@microsoft/powerquery-parser");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const trace_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/common/trace");
+const __1 = require("../../..");
+const common_1 = require("./common");
+async function inspectTypeTBinOpExpression(state, xorNode, correlationId) {
+    const trace = state.traceManager.entry(__1.InspectionTraceConstant.InspectType, inspectTypeTBinOpExpression.name, correlationId, __1.TraceUtils.xorNodeDetails(xorNode));
+    state.cancellationToken?.throwIfCancelled();
+    powerquery_parser_1.Assert.isTrue(language_1.AstUtils.isTBinOpExpressionKind(xorNode.node.kind), `xorNode isn't a TBinOpExpression`, {
+        nodeId: xorNode.node.id,
+        nodeKind: xorNode.node.kind,
+    });
+    const parentId = xorNode.node.id;
+    const children = parser_1.NodeIdMapIterator.assertIterChildrenXor(state.nodeIdMapCollection, parentId);
+    const left = children[0];
+    const operatorKind = children[1] === undefined || parser_1.XorNodeUtils.isContext(children[1])
+        ? undefined
+        : children[1].node.constantKind;
+    const right = children[2];
+    let result;
+    // ''
+    if (left === undefined) {
+        result = language_1.Type.UnknownInstance;
+    }
+    // '1'
+    else if (operatorKind === undefined) {
+        result = await (0, common_1.inspectXor)(state, left, trace.id);
+    }
+    // '1 +'
+    else if (right === undefined || parser_1.XorNodeUtils.isContext(right)) {
+        const leftType = await (0, common_1.inspectXor)(state, left, trace.id);
+        const key = partialLookupKey(leftType.kind, operatorKind);
+        const allowedTypeKinds = exports.PartialLookup.get(key);
+        if (allowedTypeKinds === undefined) {
+            result = language_1.Type.NoneInstance;
+        }
+        else if (allowedTypeKinds.size === 1) {
+            result = language_1.TypeUtils.primitiveType(leftType.isNullable, powerquery_parser_1.Assert.asDefined(allowedTypeKinds.values().next().value, "allowedTypeKinds had a size of 1, so there should be a value here."));
+        }
+        else {
+            const unionedTypePairs = [];
+            for (const kind of allowedTypeKinds.values()) {
+                unionedTypePairs.push({
+                    kind,
+                    extendedKind: undefined,
+                    isNullable: true,
+                });
+            }
+            result = language_1.TypeUtils.anyUnion(unionedTypePairs, state.traceManager, trace.id);
+        }
+    }
+    // '1 + 1'
+    else {
+        const leftType = await (0, common_1.inspectXor)(state, left, trace.id);
+        const rightType = await (0, common_1.inspectXor)(state, right, trace.id);
+        const key = lookupKey(leftType.kind, operatorKind, rightType.kind);
+        const resultTypeKind = exports.Lookup.get(key);
+        if (resultTypeKind === undefined) {
+            result = language_1.Type.NoneInstance;
+        }
+        else if (operatorKind === language_1.Constant.ArithmeticOperator.And &&
+            (resultTypeKind === language_1.Type.TypeKind.Record || resultTypeKind === language_1.Type.TypeKind.Table)) {
+            result = inspectRecordOrTableUnion(leftType, rightType);
+        }
+        else {
+            result = language_1.TypeUtils.primitiveType(leftType.isNullable || rightType.isNullable, resultTypeKind);
+        }
+    }
+    trace.exit({ [trace_1.TraceConstant.Result]: __1.TraceUtils.typeDetails(result) });
+    return result;
+}
+function inspectRecordOrTableUnion(leftType, rightType) {
+    if (leftType.kind !== rightType.kind) {
+        const details = {
+            leftTypeKind: leftType.kind,
+            rightTypeKind: rightType.kind,
+        };
+        throw new PQP.CommonError.InvariantError(`leftType.kind !== rightType.kind`, details);
+    }
+    // '[] & []' or '#table() & #table()'
+    else if (leftType.extendedKind === undefined && rightType.extendedKind === undefined) {
+        return language_1.TypeUtils.primitiveType(leftType.isNullable || rightType.isNullable, leftType.kind);
+    }
+    // '[key=value] & []' or '#table(...) & #table()`
+    // '[] & [key=value]' or `#table() & #table(...)`
+    else if ((leftType.extendedKind !== undefined && rightType.extendedKind === undefined) ||
+        (leftType.extendedKind === undefined && rightType.extendedKind !== undefined)) {
+        // The 'rightType as (...)' isn't needed, except TypeScript's checker isn't smart enough to know it.
+        const extendedKind = leftType.extendedKind !== undefined ? leftType : rightType;
+        return {
+            ...extendedKind,
+            isOpen: true,
+        };
+    }
+    // '[foo=value] & [bar=value] or #table(...) & #table(...)'
+    else if (leftType?.extendedKind === rightType?.extendedKind) {
+        // The cast should be safe since the first if statement tests their the same kind,
+        // and the above checks if they're the same extended kind.
+        if (language_1.TypeUtils.isRecord(leftType)) {
+            return unionRecordFields([leftType, rightType]);
+        }
+        else {
+            return unionTableFields([leftType, rightType]);
+        }
+    }
+    else {
+        throw new powerquery_parser_1.CommonError.InvariantError(`this should never be reached`);
+    }
+}
+function unionRecordFields([leftType, rightType]) {
+    const combinedFields = new Map(leftType.fields);
+    for (const [key, value] of rightType.fields.entries()) {
+        combinedFields.set(key, value);
+    }
+    return {
+        ...leftType,
+        fields: combinedFields,
+        isNullable: leftType.isNullable && rightType.isNullable,
+        isOpen: leftType.isOpen || rightType.isOpen,
+    };
+}
+function unionTableFields([leftType, rightType]) {
+    const combinedFields = new PQP.OrderedMap([...leftType.fields]);
+    for (const [key, value] of rightType.fields.entries()) {
+        combinedFields.set(key, value);
+    }
+    return {
+        ...leftType,
+        fields: combinedFields,
+        isNullable: leftType.isNullable && rightType.isNullable,
+        isOpen: leftType.isOpen || rightType.isOpen,
+    };
+}
+// Keys: <first operand> <operator> <second operand>
+// Values: the resulting type of the binary operation expression.
+// Eg. '1 > 3' -> Type.TypeKind.Number
+exports.Lookup = new Map([
+    ...lookupsForNullEquality(),
+    ...lookupsForRelational(language_1.Type.TypeKind.Null),
+    ...lookupsForEquality(language_1.Type.TypeKind.Null),
+    ...lookupsForRelational(language_1.Type.TypeKind.Logical),
+    ...lookupsForEquality(language_1.Type.TypeKind.Logical),
+    ...lookupsForLogical(language_1.Type.TypeKind.Logical),
+    ...lookupsForRelational(language_1.Type.TypeKind.Number),
+    ...lookupsForEquality(language_1.Type.TypeKind.Number),
+    ...lookupsForArithmetic(language_1.Type.TypeKind.Number),
+    ...lookupsForRelational(language_1.Type.TypeKind.Time),
+    ...lookupsForEquality(language_1.Type.TypeKind.Time),
+    ...lookupsForClockKind(language_1.Type.TypeKind.Time),
+    [lookupKey(language_1.Type.TypeKind.Date, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Time), language_1.Type.TypeKind.DateTime],
+    ...lookupsForRelational(language_1.Type.TypeKind.Date),
+    ...lookupsForEquality(language_1.Type.TypeKind.Date),
+    ...lookupsForClockKind(language_1.Type.TypeKind.Date),
+    [lookupKey(language_1.Type.TypeKind.Date, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Time), language_1.Type.TypeKind.DateTime],
+    ...lookupsForRelational(language_1.Type.TypeKind.DateTime),
+    ...lookupsForEquality(language_1.Type.TypeKind.DateTime),
+    ...lookupsForClockKind(language_1.Type.TypeKind.DateTime),
+    ...lookupsForRelational(language_1.Type.TypeKind.DateTimeZone),
+    ...lookupsForEquality(language_1.Type.TypeKind.DateTimeZone),
+    ...lookupsForClockKind(language_1.Type.TypeKind.DateTimeZone),
+    ...lookupsForRelational(language_1.Type.TypeKind.Duration),
+    ...lookupsForEquality(language_1.Type.TypeKind.Duration),
+    [
+        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Addition, language_1.Type.TypeKind.Duration),
+        language_1.Type.TypeKind.Duration,
+    ],
+    [
+        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Subtraction, language_1.Type.TypeKind.Duration),
+        language_1.Type.TypeKind.Duration,
+    ],
+    [
+        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Multiplication, language_1.Type.TypeKind.Number),
+        language_1.Type.TypeKind.Duration,
+    ],
+    [
+        lookupKey(language_1.Type.TypeKind.Number, language_1.Constant.ArithmeticOperator.Multiplication, language_1.Type.TypeKind.Duration),
+        language_1.Type.TypeKind.Duration,
+    ],
+    [
+        lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Division, language_1.Type.TypeKind.Number),
+        language_1.Type.TypeKind.Duration,
+    ],
+    ...lookupsForRelational(language_1.Type.TypeKind.Text),
+    ...lookupsForEquality(language_1.Type.TypeKind.Text),
+    [lookupKey(language_1.Type.TypeKind.Text, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Text), language_1.Type.TypeKind.Text],
+    ...lookupsForRelational(language_1.Type.TypeKind.Binary),
+    ...lookupsForEquality(language_1.Type.TypeKind.Binary),
+    ...lookupsForEquality(language_1.Type.TypeKind.List),
+    [lookupKey(language_1.Type.TypeKind.List, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.List), language_1.Type.TypeKind.List],
+    ...lookupsForEquality(language_1.Type.TypeKind.Record),
+    [lookupKey(language_1.Type.TypeKind.Record, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Record), language_1.Type.TypeKind.Record],
+    ...lookupsForEquality(language_1.Type.TypeKind.Table),
+    [lookupKey(language_1.Type.TypeKind.Table, language_1.Constant.ArithmeticOperator.And, language_1.Type.TypeKind.Table), language_1.Type.TypeKind.Table],
+]);
+// Keys: <first operand> <operator>
+// Values: a set of types that are allowed for <second operand>
+// Eg. '1 + ' ->
+exports.PartialLookup = new Map(
+// Grab the keys
+[...exports.Lookup.keys()]
+    .reduce((binaryExpressionPartialLookup, key, _currentIndex, _array) => {
+    const lastDeliminatorIndex = key.lastIndexOf(",");
+    // Grab '<first operand> , <operator>'.
+    const partialKey = key.slice(0, lastDeliminatorIndex);
+    // Grab '<second operand>'.
+    const potentialNewValue = key.slice(lastDeliminatorIndex + 1);
+    // Add the potentialNewValue if it's a new Type.
+    const values = binaryExpressionPartialLookup.get(partialKey);
+    // First occurance of '<first operand> , <operator>'
+    if (values === undefined) {
+        binaryExpressionPartialLookup.set(partialKey, new Set([potentialNewValue]));
+    }
+    else {
+        values.add(potentialNewValue);
+    }
+    return binaryExpressionPartialLookup;
+}, new Map())
+    .entries());
+function lookupKey(leftTypeKind, operatorKind, rightTypeKind) {
+    return `${leftTypeKind},${operatorKind},${rightTypeKind}`;
+}
+function partialLookupKey(leftTypeKind, operatorKind) {
+    return `${leftTypeKind},${operatorKind}`;
+}
+function lookupsForRelational(typeKind) {
+    return [
+        [lookupKey(typeKind, language_1.Constant.RelationalOperator.GreaterThan, typeKind), language_1.Type.TypeKind.Logical],
+        [lookupKey(typeKind, language_1.Constant.RelationalOperator.GreaterThanEqualTo, typeKind), language_1.Type.TypeKind.Logical],
+        [lookupKey(typeKind, language_1.Constant.RelationalOperator.LessThan, typeKind), language_1.Type.TypeKind.Logical],
+        [lookupKey(typeKind, language_1.Constant.RelationalOperator.LessThanEqualTo, typeKind), language_1.Type.TypeKind.Logical],
+    ];
+}
+function lookupsForEquality(typeKind) {
+    return [
+        [lookupKey(typeKind, language_1.Constant.EqualityOperator.EqualTo, typeKind), language_1.Type.TypeKind.Logical],
+        [lookupKey(typeKind, language_1.Constant.EqualityOperator.NotEqualTo, typeKind), language_1.Type.TypeKind.Logical],
+    ];
+}
+function lookupsForNullEquality() {
+    const results = [];
+    for (const typeKind of language_1.Type.TypeKinds) {
+        results.push([
+            lookupKey(typeKind, language_1.Constant.EqualityOperator.EqualTo, language_1.Type.TypeKind.Null),
+            language_1.Type.TypeKind.Logical,
+        ]);
+        results.push([
+            lookupKey(typeKind, language_1.Constant.EqualityOperator.NotEqualTo, language_1.Type.TypeKind.Null),
+            language_1.Type.TypeKind.Logical,
+        ]);
+        results.push([
+            lookupKey(language_1.Type.TypeKind.Null, language_1.Constant.EqualityOperator.EqualTo, typeKind),
+            language_1.Type.TypeKind.Logical,
+        ]);
+        results.push([
+            lookupKey(language_1.Type.TypeKind.Null, language_1.Constant.EqualityOperator.NotEqualTo, typeKind),
+            language_1.Type.TypeKind.Logical,
+        ]);
+    }
+    return results;
+}
+// Note: does not include the and <'&'> Constant.
+function lookupsForArithmetic(typeKind) {
+    return [
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Addition, typeKind), typeKind],
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Division, typeKind), typeKind],
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Multiplication, typeKind), typeKind],
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, typeKind), typeKind],
+    ];
+}
+function lookupsForLogical(typeKind) {
+    return [
+        [lookupKey(typeKind, language_1.Constant.LogicalOperator.And, typeKind), typeKind],
+        [lookupKey(typeKind, language_1.Constant.LogicalOperator.Or, typeKind), typeKind],
+    ];
+}
+function lookupsForClockKind(typeKind) {
+    return [
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Addition, language_1.Type.TypeKind.Duration), typeKind],
+        [lookupKey(language_1.Type.TypeKind.Duration, language_1.Constant.ArithmeticOperator.Addition, typeKind), typeKind],
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, language_1.Type.TypeKind.Duration), typeKind],
+        [lookupKey(typeKind, language_1.Constant.ArithmeticOperator.Subtraction, typeKind), language_1.Type.TypeKind.Duration],
+    ];
+}
 //# sourceMappingURL=inspectTypeTBinOpExpression.js.map