@zzzen/pyright-internal 1.2.0-dev.20261101 → 1.2.0-dev.20261108

package/dist/analyzer/typeEvaluator/collectionInference.js

@@ -0,0 +1,695 @@
+"use strict";
+/*
+ * collectionInference.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * collectionInference implementation, using evaluator-owned dependencies and state.
+ */
+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.createCollectionInference = createCollectionInference;
+const debug_1 = require("../../common/debug");
+const diagnostic_1 = require("../../common/diagnostic");
+const diagnosticRules_1 = require("../../common/diagnosticRules");
+const localize_1 = require("../../localization/localize");
+const parseNodes_1 = require("../../parser/parseNodes");
+const constraintSolver_1 = require("../constraintSolver");
+const constraintTracker_1 = require("../constraintTracker");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const tuples_1 = require("../tuples");
+const typedDicts_1 = require("../typedDicts");
+const typeEvaluatorTypes_1 = require("../typeEvaluatorTypes");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Infers collection entries and comprehension clauses, including assignment and diagnostic effects.
+function createCollectionInference(context) {
+    const { addDiagnostic, assignType, assignTypeToExpression, convertSpecialFormToRuntimeValue, evaluatorInterface, getBuiltInObject, getBuiltInType, getNoneType, getObjectType, getTupleClassType, getTypeOfExpression, getTypeOfIterator, getTypeVarScopesForNode, getTypingType, inferVarianceForClass, isTypeHashable, makeTopLevelTypeVarsConcrete, maxEntriesToUseForInference, nodeInfo, printType, solveAndApplyConstraints, stripLiteralValue, } = context;
+    function getTypeOfDictionaryWithContext(node, flags, inferenceContext, expectedDiagAddendum) {
+        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+        let concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
+        if (!(0, types_1.isClassInstance)(concreteExpectedType)) {
+            return undefined;
+        }
+        // Handle TypedDict's as a special case.
+        if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
+            // Remove any conditions associated with the type so the resulting type isn't
+            // considered compatible with a bound TypeVar.
+            concreteExpectedType = types_1.TypeBase.cloneForCondition(concreteExpectedType, undefined);
+            const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
+            const { keyTypes, valueTypes, isIncomplete } = inferDictionaryEntries(node, flags, {
+                forceStrictInference: true,
+                isValueTypeInvariant: true,
+                expectedTypedDictEntries,
+                expectedDiagAddendum,
+            });
+            const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
+            // Don't overwrite existing expectedDiagAddendum messages if they were
+            // already provided by inferDictionaryEntries.
+            expectedDiagAddendum?.isEmpty() ? expectedDiagAddendum : undefined);
+            if (resultTypedDict) {
+                return {
+                    type: resultTypedDict,
+                    isIncomplete,
+                };
+            }
+            return undefined;
+        }
+        let expectedKeyType;
+        let expectedValueType;
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            expectedKeyType = inferenceContext.expectedType;
+            expectedValueType = inferenceContext.expectedType;
+        }
+        else {
+            const builtInDict = getBuiltInObject(node, 'dict');
+            if (!(0, types_1.isClassInstance)(builtInDict)) {
+                return undefined;
+            }
+            const dictConstraints = new constraintTracker_1.ConstraintTracker();
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictConstraints, getTypeVarScopesForNode(node), node.start)) {
+                return undefined;
+            }
+            const specializedDict = solveAndApplyConstraints(types_1.ClassType.cloneAsInstantiable(builtInDict), dictConstraints);
+            if (!specializedDict.priv.typeArgs || specializedDict.priv.typeArgs.length !== 2) {
+                return undefined;
+            }
+            expectedKeyType = specializedDict.priv.typeArgs[0];
+            expectedValueType = specializedDict.priv.typeArgs[1];
+        }
+        // Dict and MutableMapping types have invariant value types, so they
+        // cannot be narrowed further. Other super-types like Mapping, Collection,
+        // and Iterable use covariant value types, so they can be narrowed.
+        let isValueTypeInvariant = false;
+        if ((0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+            if (inferenceContext.expectedType.shared.typeParams.length >= 2) {
+                const valueTypeParam = inferenceContext.expectedType.shared.typeParams[1];
+                if (types_1.TypeVarType.getVariance(valueTypeParam) === 2 /* Variance.Invariant */) {
+                    isValueTypeInvariant = true;
+                }
+            }
+        }
+        const { keyTypes, valueTypes, isIncomplete, typeErrors } = inferDictionaryEntries(node, flags, {
+            forceStrictInference: true,
+            isValueTypeInvariant,
+            expectedKeyType,
+            expectedValueType,
+            expectedDiagAddendum,
+        });
+        const specializedKeyType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedKeyType), keyTypes.map((result) => result.type), 
+        /* isNarrowable */ false);
+        const specializedValueType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedValueType), valueTypes.map((result) => result.type), !isValueTypeInvariant);
+        if (!specializedKeyType || !specializedValueType) {
+            return undefined;
+        }
+        const type = getBuiltInObject(node, 'dict', [specializedKeyType, specializedValueType]);
+        return { type, isIncomplete, typeErrors };
+    }
+    function getTypeOfDictionaryInferred(node, flags, hasExpectedType) {
+        const fallbackType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
+        let keyType = fallbackType;
+        let valueType = fallbackType;
+        let isEmptyContainer = false;
+        const { keyTypes: keyTypeResults, valueTypes: valueTypeResults, isIncomplete, typeErrors, } = inferDictionaryEntries(node, flags, {
+            forceStrictInference: hasExpectedType,
+            isValueTypeInvariant: false,
+        });
+        // Strip any literal values and TypeForm types.
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
+        if (keyTypes.length > 0) {
+            if (nodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
+                keyType = (0, types_1.combineTypes)(keyTypes);
+            }
+            else {
+                keyType = (0, typeUtils_1.areTypesSame)(keyTypes, { ignorePseudoGeneric: true }) ? keyTypes[0] : fallbackType;
+            }
+        }
+        else {
+            keyType = fallbackType;
+        }
+        // If the value type differs and we're not using "strict inference mode",
+        // we need to back off because we can't properly represent the mappings
+        // between different keys and associated value types. If all the values
+        // are the same type, we'll assume that all values in this dictionary should
+        // be the same.
+        if (valueTypes.length > 0) {
+            if (nodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
+                valueType = (0, types_1.combineTypes)(valueTypes);
+            }
+            else {
+                valueType = (0, typeUtils_1.areTypesSame)(valueTypes, { ignorePseudoGeneric: true }) ? valueTypes[0] : fallbackType;
+            }
+        }
+        else {
+            valueType = fallbackType;
+            isEmptyContainer = true;
+        }
+        const dictClass = getBuiltInType(node, 'dict');
+        const type = (0, types_1.isInstantiableClass)(dictClass)
+            ? types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictClass, [keyType, valueType], 
+            /* isTypeArgExplicit */ true, 
+            /* includeSubclasses */ undefined, 
+            /* tupleTypeArgs */ undefined, isEmptyContainer))
+            : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
+        return { type, isIncomplete, typeErrors };
+    }
+    function inferDictionaryEntries(node, flags, options) {
+        const results = {
+            keyTypes: [],
+            valueTypes: [],
+            isIncomplete: false,
+            typeErrors: false,
+        };
+        // The sampling limit restricts retained types, not evaluation or diagnostics.
+        node.d.items.forEach((entryNode, index) => {
+            const retainEntryTypes = options.forceStrictInference || index < maxEntriesToUseForInference;
+            let addUnknown = true;
+            if (entryNode.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
+                inferDictionaryKeyEntry(node, entryNode, flags, options, results, retainEntryTypes);
+                addUnknown = false;
+            }
+            else if (entryNode.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
+                addUnknown = !tryInferDictionaryExpansion(entryNode, flags, options, results, retainEntryTypes);
+            }
+            else if (entryNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
+                const dictEntryTypeResult = getElementTypeFromComprehension(entryNode, flags | 268435456 /* EvalFlags.StripTupleLiterals */, options.expectedValueType, options.expectedKeyType);
+                const dictEntryType = dictEntryTypeResult.type;
+                if (dictEntryTypeResult.isIncomplete) {
+                    results.isIncomplete = true;
+                }
+                if (dictEntryTypeResult.typeErrors) {
+                    results.typeErrors = true;
+                }
+                // The result should be a tuple.
+                if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
+                    const typeArgs = dictEntryType.priv.tupleTypeArgs?.map((t) => t.type);
+                    if (typeArgs && typeArgs.length === 2) {
+                        if (retainEntryTypes) {
+                            results.keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                            results.valueTypes.push({ node: entryNode, type: typeArgs[1] });
+                        }
+                        addUnknown = false;
+                    }
+                }
+            }
+            if (addUnknown && retainEntryTypes) {
+                results.keyTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
+                results.valueTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
+            }
+        });
+        return results;
+    }
+    function inferDictionaryKeyEntry(node, entryNode, flags, options, results, retainEntryTypes) {
+        const { expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum } = options;
+        // Keys aren't type expressions, even within an inlined TypedDict annotation.
+        const keyFlags = flags & ~(256 /* EvalFlags.TypeExpression */ | 8 /* EvalFlags.StrLiteralAsType */ | 128 /* EvalFlags.InstantiableType */);
+        const keyTypeResult = getTypeOfExpression(entryNode.d.keyExpr, keyFlags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType ?? (options.forceStrictInference ? types_1.NeverType.createNever() : undefined)));
+        if (keyTypeResult.isIncomplete) {
+            results.isIncomplete = true;
+        }
+        if (keyTypeResult.typeErrors) {
+            results.typeErrors = true;
+        }
+        const keyType = keyTypeResult.type;
+        if (!keyTypeResult.isIncomplete && !keyTypeResult.typeErrors) {
+            verifySetEntryOrDictKeyIsHashable(entryNode.d.keyExpr, keyType, /* isDictKey */ true);
+        }
+        if (expectedDiagAddendum && keyTypeResult.expectedTypeDiagAddendum) {
+            expectedDiagAddendum.addAddendum(keyTypeResult.expectedTypeDiagAddendum);
+        }
+        let effectiveValueType;
+        if (expectedTypedDictEntries &&
+            (0, types_1.isClassInstance)(keyType) &&
+            types_1.ClassType.isBuiltIn(keyType, 'str') &&
+            (0, typeUtils_1.isLiteralType)(keyType) &&
+            (expectedTypedDictEntries.knownItems.has(keyType.priv.literalValue) ||
+                expectedTypedDictEntries.extraItems)) {
+            effectiveValueType =
+                expectedTypedDictEntries.knownItems.get(keyType.priv.literalValue)?.valueType ??
+                    expectedTypedDictEntries.extraItems?.valueType;
+        }
+        else {
+            effectiveValueType =
+                expectedValueType ?? (options.forceStrictInference ? types_1.NeverType.createNever() : undefined);
+        }
+        if (effectiveValueType) {
+            const liveTypeVarScopes = getTypeVarScopesForNode(node);
+            effectiveValueType = (0, typeUtils_1.transformExpectedType)(effectiveValueType, liveTypeVarScopes, node.start);
+        }
+        const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
+        let valueTypeResult = getTypeOfExpression(entryNode.d.valueExpr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
+        if (entryInferenceContext && !valueTypeResult.typeErrors) {
+            const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !options.isValueTypeInvariant);
+            if (fromExpectedType) {
+                valueTypeResult = { ...valueTypeResult, type: fromExpectedType };
+            }
+        }
+        if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
+            expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
+        }
+        if (valueTypeResult.isIncomplete) {
+            results.isIncomplete = true;
+        }
+        if (valueTypeResult.typeErrors) {
+            results.typeErrors = true;
+        }
+        if (retainEntryTypes) {
+            // A later literal key replaces its earlier key/value pair.
+            if ((0, types_1.isClass)(keyType) && (0, typeUtils_1.isLiteralType)(keyType)) {
+                const existingIndex = results.keyTypes.findIndex((kt) => (0, types_1.isTypeSame)(keyType, kt.type));
+                if (existingIndex >= 0) {
+                    results.keyTypes.splice(existingIndex, 1);
+                    results.valueTypes.splice(existingIndex, 1);
+                }
+            }
+            results.keyTypes.push({ node: entryNode.d.keyExpr, type: keyType });
+            results.valueTypes.push({ node: entryNode.d.valueExpr, type: valueTypeResult.type });
+        }
+    }
+    // Returns whether the expansion has a usable key/value shape, even beyond the sampling limit.
+    function tryInferDictionaryExpansion(entryNode, flags, options, results, retainEntryTypes) {
+        let expectedType;
+        if (options.expectedKeyType && options.expectedValueType) {
+            if (context.prefetched?.supportsKeysAndGetItemClass &&
+                (0, types_1.isInstantiableClass)(context.prefetched.supportsKeysAndGetItemClass)) {
+                expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(context.prefetched.supportsKeysAndGetItemClass, [
+                    options.expectedKeyType,
+                    options.expectedValueType,
+                ]));
+            }
+        }
+        const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
+        let unexpandedTypeResult = getTypeOfExpression(entryNode.d.expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
+        if (entryInferenceContext && !unexpandedTypeResult.typeErrors) {
+            const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !options.isValueTypeInvariant);
+            if (fromExpectedType) {
+                unexpandedTypeResult = { ...unexpandedTypeResult, type: fromExpectedType };
+            }
+        }
+        if (unexpandedTypeResult.isIncomplete) {
+            results.isIncomplete = true;
+        }
+        if (unexpandedTypeResult.typeErrors) {
+            results.typeErrors = true;
+        }
+        const unexpandedType = unexpandedTypeResult.type;
+        if ((0, types_1.isAnyOrUnknown)(unexpandedType)) {
+            if (retainEntryTypes) {
+                results.keyTypes.push({ node: entryNode, type: unexpandedType });
+                results.valueTypes.push({ node: entryNode, type: unexpandedType });
+            }
+            return true;
+        }
+        if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
+            if (context.prefetched?.strClass && (0, types_1.isInstantiableClass)(context.prefetched.strClass)) {
+                const strObject = types_1.ClassType.cloneAsInstance(context.prefetched.strClass);
+                const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
+                /* allowNarrowed */ true);
+                tdEntries.knownItems.forEach((entry, name) => {
+                    if (!options.expectedTypedDictEntries || entry.isRequired || entry.isProvided) {
+                        results.keyTypes.push({
+                            node: entryNode,
+                            type: types_1.ClassType.cloneWithLiteral(strObject, name),
+                        });
+                        results.valueTypes.push({ node: entryNode, type: entry.valueType });
+                    }
+                });
+                if (!options.expectedTypedDictEntries) {
+                    // Open TypedDicts can contain extra items with arbitrary value types.
+                    results.keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneAsInstance(strObject) });
+                    results.valueTypes.push({
+                        node: entryNode,
+                        type: tdEntries.extraItems?.valueType ?? getObjectType(),
+                    });
+                }
+                return true;
+            }
+        }
+        else if (context.prefetched?.supportsKeysAndGetItemClass &&
+            (0, types_1.isInstantiableClass)(context.prefetched.supportsKeysAndGetItemClass)) {
+            const mappingConstraints = new constraintTracker_1.ConstraintTracker();
+            const supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(context.prefetched.supportsKeysAndGetItemClass);
+            if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType, 
+            /* diag */ undefined, mappingConstraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
+                const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
+                const typeArgs = specializedMapping.priv.typeArgs;
+                if (typeArgs && typeArgs.length >= 2) {
+                    if (retainEntryTypes) {
+                        results.keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                        results.valueTypes.push({ node: entryNode, type: typeArgs[1] });
+                    }
+                    return true;
+                }
+            }
+            else {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dictUnpackIsNotMapping(), entryNode);
+            }
+        }
+        return false;
+    }
+    function getTypeOfListOrSetWithContext(node, flags, inferenceContext) {
+        const builtInClassName = node.nodeType === 34 /* ParseNodeType.List */ ? 'list' : 'set';
+        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+        let isIncomplete = false;
+        let typeErrors = false;
+        const verifyHashable = node.nodeType === 45 /* ParseNodeType.Set */;
+        const expectedEntryType = getExpectedEntryTypeForIterable(node, getBuiltInType(node, builtInClassName), inferenceContext);
+        if (!expectedEntryType) {
+            return undefined;
+        }
+        const entryTypes = [];
+        const expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
+        node.d.items.forEach((entry) => {
+            let entryTypeResult;
+            if (entry.nodeType === 11 /* ParseNodeType.Comprehension */) {
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */, expectedEntryType);
+            }
+            else {
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
+            }
+            entryTypes.push(entryTypeResult.type);
+            if (entryTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            if (entryTypeResult.typeErrors) {
+                typeErrors = true;
+            }
+            if (entryTypeResult.expectedTypeDiagAddendum) {
+                expectedTypeDiagAddendum.addAddendum(entryTypeResult.expectedTypeDiagAddendum);
+            }
+            if (verifyHashable && !entryTypeResult.isIncomplete && !entryTypeResult.typeErrors) {
+                verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
+            }
+        });
+        let isTypeInvariant = false;
+        if ((0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+            inferVarianceForClass(inferenceContext.expectedType);
+            if (inferenceContext.expectedType.shared.typeParams.some((t) => types_1.TypeVarType.getVariance(t) === 2 /* Variance.Invariant */)) {
+                isTypeInvariant = true;
+            }
+        }
+        const specializedEntryType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedEntryType), entryTypes, !isTypeInvariant);
+        if (!specializedEntryType) {
+            return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
+        }
+        const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
+        return { type, isIncomplete, typeErrors, expectedTypeDiagAddendum };
+    }
+    function getExpectedEntryTypeForIterable(node, expectedClassType, inferenceContext) {
+        if (!inferenceContext) {
+            return undefined;
+        }
+        if (!expectedClassType || !(0, types_1.isInstantiableClass)(expectedClassType)) {
+            return undefined;
+        }
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            return inferenceContext.expectedType;
+        }
+        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+            return undefined;
+        }
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, constraints, getTypeVarScopesForNode(node), node.start)) {
+            return undefined;
+        }
+        const specializedListOrSet = solveAndApplyConstraints(expectedClassType, constraints);
+        if (!specializedListOrSet.priv.typeArgs) {
+            return undefined;
+        }
+        return specializedListOrSet.priv.typeArgs[0];
+    }
+    function getTypeOfListOrSetInferred(node, flags, hasExpectedType) {
+        const builtInClassName = node.nodeType === 34 /* ParseNodeType.List */ ? 'list' : 'set';
+        const verifyHashable = node.nodeType === 45 /* ParseNodeType.Set */;
+        let isEmptyContainer = false;
+        let isIncomplete = false;
+        let typeErrors = false;
+        let entryTypes = [];
+        node.d.items.forEach((entry, index) => {
+            let entryTypeResult;
+            if (entry.nodeType === 11 /* ParseNodeType.Comprehension */ && !entry.d.isGenerator) {
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
+            }
+            else {
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
+            }
+            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, !hasExpectedType));
+            if (entryTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            if (entryTypeResult.typeErrors) {
+                typeErrors = true;
+            }
+            if (hasExpectedType || index < maxEntriesToUseForInference) {
+                entryTypes.push(entryTypeResult.type);
+            }
+            if (verifyHashable && !entryTypeResult.isIncomplete && !entryTypeResult.typeErrors) {
+                verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
+            }
+        });
+        entryTypes = entryTypes.map((t) => stripLiteralValue(t));
+        let inferredEntryType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
+        if (entryTypes.length > 0) {
+            const fileInfo = nodeInfo.getFileInfo(node);
+            // If there was an expected type or we're using strict list inference,
+            // combine the types into a union.
+            if ((builtInClassName === 'list' && fileInfo.diagnosticRuleSet.strictListInference) ||
+                (builtInClassName === 'set' && fileInfo.diagnosticRuleSet.strictSetInference) ||
+                hasExpectedType) {
+                inferredEntryType = (0, types_1.combineTypes)(entryTypes, { maxSubtypeCount: typeEvaluatorTypes_1.maxSubtypesForInferredType });
+            }
+            else {
+                // Is the list or set homogeneous? If so, use stricter rules. Otherwise relax the rules.
+                inferredEntryType = (0, typeUtils_1.areTypesSame)(entryTypes, { ignorePseudoGeneric: true })
+                    ? entryTypes[0]
+                    : inferredEntryType;
+            }
+        }
+        else {
+            isEmptyContainer = true;
+        }
+        const listOrSetClass = getBuiltInType(node, builtInClassName);
+        const type = (0, types_1.isInstantiableClass)(listOrSetClass)
+            ? types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(listOrSetClass, [inferredEntryType], 
+            /* isTypeArgExplicit */ true, 
+            /* includeSubclasses */ undefined, 
+            /* tupleTypeArgs */ undefined, isEmptyContainer))
+            : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
+        return { type, isIncomplete, typeErrors };
+    }
+    function getTypeOfComprehension(node, flags, inferenceContext) {
+        let isIncomplete = false;
+        let typeErrors = false;
+        // If any of the "for" clauses are marked async or any of the "if" clauses
+        // or any clause other than the leftmost "for" contain an "await" operator,
+        // it is treated as an async generator.
+        let isAsync = node.d.forIfNodes.some((comp, index) => {
+            if (comp.nodeType === 12 /* ParseNodeType.ComprehensionFor */ && comp.d.isAsync) {
+                return true;
+            }
+            return index > 0 && ParseTreeUtils.containsAwaitNode(comp);
+        });
+        let type = types_1.UnknownType.create();
+        if (ParseTreeUtils.containsAwaitNode(node.d.expr)) {
+            isAsync = true;
+        }
+        const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
+        const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
+        const elementTypeResult = getElementTypeFromComprehension(node, flags | 268435456 /* EvalFlags.StripTupleLiterals */, expectedEntryType);
+        if (elementTypeResult.isIncomplete) {
+            isIncomplete = true;
+        }
+        if (elementTypeResult.typeErrors) {
+            typeErrors = true;
+        }
+        let elementType = elementTypeResult.type;
+        if (!expectedEntryType || !(0, typeUtils_1.containsLiteralType)(expectedEntryType)) {
+            elementType = stripLiteralValue(elementType);
+        }
+        if (builtInIteratorType && (0, types_1.isInstantiableClass)(builtInIteratorType)) {
+            type = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(builtInIteratorType, isAsync ? [elementType, getNoneType()] : [elementType, getNoneType(), getNoneType()]));
+        }
+        return { type, isIncomplete, typeErrors };
+    }
+    function getElementTypeFromComprehension(node, flags, expectedValueOrElementType, expectedKeyType) {
+        let isIncomplete = false;
+        let typeErrors = false;
+        // "Execute" the list comprehensions from start to finish.
+        for (const forIfNode of node.d.forIfNodes) {
+            if (evaluateComprehensionForIf(forIfNode)) {
+                isIncomplete = true;
+            }
+        }
+        let type = types_1.UnknownType.create();
+        if (node.d.expr.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
+            // Create a tuple with the key/value types.
+            const keyTypeResult = getTypeOfExpression(node.d.expr.d.keyExpr, flags, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
+            if (keyTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            if (keyTypeResult.typeErrors) {
+                typeErrors = true;
+            }
+            let keyType = keyTypeResult.type;
+            if (!expectedKeyType || !(0, typeUtils_1.containsLiteralType)(expectedKeyType)) {
+                keyType = stripLiteralValue(keyType);
+            }
+            const valueTypeResult = getTypeOfExpression(node.d.expr.d.valueExpr, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            if (valueTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            if (valueTypeResult.typeErrors) {
+                typeErrors = true;
+            }
+            let valueType = valueTypeResult.type;
+            if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
+                valueType = stripLiteralValue(valueType);
+            }
+            type = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
+                { type: keyType, isUnbounded: false },
+                { type: valueType, isUnbounded: false },
+            ]);
+        }
+        else if (node.d.expr.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
+            // The parser should have reported an error in this case because it's not allowed.
+            getTypeOfExpression(node.d.expr.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+        }
+        else if ((0, parseNodes_1.isExpressionNode)(node)) {
+            const exprTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            if (exprTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            if (exprTypeResult.typeErrors) {
+                typeErrors = true;
+            }
+            type = exprTypeResult.type;
+        }
+        return { type, isIncomplete, typeErrors };
+    }
+    function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
+        // Verify that the type is hashable.
+        if (!isTypeHashable(type)) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.LocAddendum.unhashableType().format({ type: printType(type) }));
+            const message = isDictKey ? localize_1.LocMessage.unhashableDictKey() : localize_1.LocMessage.unhashableSetEntry();
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnhashable, message + diag.getString(), entry);
+        }
+    }
+    function inferTypeArgFromExpectedEntryType(inferenceContext, entryTypes, isNarrowable) {
+        // If the expected type is Any, the resulting type becomes Any.
+        if ((0, types_1.isAny)(inferenceContext.expectedType)) {
+            return inferenceContext.expectedType;
+        }
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        const expectedType = inferenceContext.expectedType;
+        let isCompatible = true;
+        entryTypes.forEach((entryType) => {
+            if (isCompatible && !assignType(expectedType, entryType, /* diag */ undefined, constraints)) {
+                isCompatible = false;
+            }
+        });
+        if (!isCompatible) {
+            return undefined;
+        }
+        if (isNarrowable && entryTypes.length > 0) {
+            const combinedTypes = (0, types_1.combineTypes)(entryTypes);
+            return (0, typeUtils_1.containsLiteralType)(inferenceContext.expectedType)
+                ? combinedTypes
+                : stripLiteralValue(combinedTypes);
+        }
+        return (0, typeUtils_1.mapSubtypes)(solveAndApplyConstraints(inferenceContext.expectedType, constraints, {
+            replaceUnsolved: {
+                scopeIds: [],
+                tupleClassType: getTupleClassType(),
+            },
+        }), (subtype) => {
+            if (entryTypes.length !== 1) {
+                return subtype;
+            }
+            const entryType = entryTypes[0];
+            // If the entry type is a TypedDict instance, clone it with additional information.
+            if ((0, types_1.isTypeSame)(subtype, entryType, { ignoreTypedDictNarrowEntries: true }) &&
+                (0, types_1.isClass)(subtype) &&
+                (0, types_1.isClass)(entryType) &&
+                types_1.ClassType.isTypedDictClass(entryType)) {
+                return types_1.ClassType.cloneForNarrowedTypedDictEntries(subtype, entryType.priv.typedDictNarrowedEntries);
+            }
+            return subtype;
+        });
+    }
+    function evaluateComprehensionForIf(node) {
+        let isIncomplete = false;
+        if (node.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
+            const iterableTypeResult = getTypeOfExpression(node.d.iterableExpr);
+            if (iterableTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            const iterableType = stripLiteralValue(iterableTypeResult.type);
+            const itemTypeResult = getTypeOfIterator({ type: iterableType, isIncomplete: iterableTypeResult.isIncomplete }, !!node.d.isAsync, node.d.iterableExpr) ?? { type: types_1.UnknownType.create(), isIncomplete: iterableTypeResult.isIncomplete };
+            const targetExpr = node.d.targetExpr;
+            assignTypeToExpression(targetExpr, itemTypeResult, node.d.iterableExpr);
+        }
+        else {
+            (0, debug_1.assert)(node.nodeType === 13 /* ParseNodeType.ComprehensionIf */);
+            // Evaluate the test expression to validate it and mark symbols
+            // as referenced. This doesn't affect the type of the evaluated
+            // comprehension, but it is important for evaluating intermediate
+            // expressions such as assignment expressions that can affect other
+            // subexpressions.
+            getTypeOfExpression(node.d.testExpr);
+        }
+        return isIncomplete;
+    }
+    return {
+        getTypeOfDictionaryWithContext,
+        getTypeOfDictionaryInferred,
+        getTypeOfListOrSetWithContext,
+        getTypeOfListOrSetInferred,
+        getTypeOfComprehension,
+        evaluateComprehensionForIf,
+    };
+}
+//# sourceMappingURL=collectionInference.js.map