@zzzen/pyright-internal 1.1.254

package/dist/analyzer/patternMatching.js

@@ -0,0 +1,866 @@
+"use strict";
+/*
+ * patternMatching.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Type evaluation logic for evaluating and narrowing types
+ * related to "match" and "case" statements as documented in
+ * PEP 634.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateClassPattern = exports.assignTypeToPatternTargets = exports.narrowTypeBasedOnPattern = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
+const debug_1 = require("../common/debug");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const localize_1 = require("../localization/localize");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const constraintSolver_1 = require("./constraintSolver");
+const typedDicts_1 = require("./typedDicts");
+const typeGuards_1 = require("./typeGuards");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+const typeVarContext_1 = require("./typeVarContext");
+// PEP 634 indicates that several built-in classes are handled differently
+// when used with class pattern matching.
+const classPatternSpecialCases = [
+    'builtins.bool',
+    'builtins.bytearray',
+    'builtins.bytes',
+    'builtins.dict',
+    'builtins.float',
+    'builtins.frozenset',
+    'builtins.int',
+    'builtins.list',
+    'builtins.set',
+    'builtins.str',
+    'builtins.tuple',
+];
+function narrowTypeBasedOnPattern(evaluator, type, pattern, isPositiveTest) {
+    switch (pattern.nodeType) {
+        case 65 /* PatternSequence */: {
+            return narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 67 /* PatternLiteral */: {
+            return narrowTypeBasedOnLiteralPattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 68 /* PatternClass */: {
+            return narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 66 /* PatternAs */: {
+            return narrowTypeBasedOnAsPattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 70 /* PatternMapping */: {
+            return narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 73 /* PatternValue */: {
+            return narrowTypeBasedOnValuePattern(evaluator, type, pattern, isPositiveTest);
+        }
+        case 69 /* PatternCapture */: {
+            // A capture captures everything, so nothing remains in the negative case.
+            return isPositiveTest ? type : types_1.NeverType.createNever();
+        }
+        case 0 /* Error */: {
+            return type;
+        }
+    }
+}
+exports.narrowTypeBasedOnPattern = narrowTypeBasedOnPattern;
+function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTest) {
+    let sequenceInfo = getSequencePatternInfo(evaluator, type, pattern.entries.length, pattern.starEntryIndex);
+    // Further narrow based on pattern entry types.
+    sequenceInfo = sequenceInfo.filter((entry) => {
+        if (entry.definiteNoMatch) {
+            if (isPositiveTest) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        let isPlausibleMatch = true;
+        let isDefiniteMatch = true;
+        const narrowedEntryTypes = [];
+        let canNarrowTuple = entry.isTuple;
+        // If the subject has an indeterminate length but the pattern does not accept
+        // an arbitrary number of entries or accepts at least one non-star entry,
+        // we can't prove that it's a definite match.
+        if (entry.isIndeterminateLength) {
+            if (pattern.entries.length !== 1 || pattern.starEntryIndex !== 0) {
+                isDefiniteMatch = false;
+            }
+        }
+        pattern.entries.forEach((sequenceEntry, index) => {
+            const entryType = getTypeOfPatternSequenceEntry(evaluator, pattern, entry, index, pattern.entries.length, pattern.starEntryIndex, 
+            /* unpackStarEntry */ true, 
+            /* isSubjectObject */ false);
+            const narrowedEntryType = narrowTypeBasedOnPattern(evaluator, entryType, sequenceEntry, isPositiveTest);
+            if (isPositiveTest) {
+                if (index === pattern.starEntryIndex) {
+                    if ((0, types_1.isClassInstance)(narrowedEntryType) &&
+                        narrowedEntryType.tupleTypeArguments &&
+                        !(0, typeUtils_1.isUnboundedTupleClass)(narrowedEntryType) &&
+                        narrowedEntryType.tupleTypeArguments) {
+                        (0, collectionUtils_1.appendArray)(narrowedEntryTypes, narrowedEntryType.tupleTypeArguments.map((t) => t.type));
+                    }
+                    else {
+                        narrowedEntryTypes.push(narrowedEntryType);
+                        canNarrowTuple = false;
+                    }
+                }
+                else {
+                    narrowedEntryTypes.push(narrowedEntryType);
+                    if ((0, types_1.isNever)(narrowedEntryType)) {
+                        isPlausibleMatch = false;
+                    }
+                }
+            }
+            else {
+                if (!(0, types_1.isNever)(narrowedEntryType) || (0, types_1.isAnyOrUnknown)(entryType)) {
+                    isDefiniteMatch = false;
+                }
+            }
+        });
+        if (!isPositiveTest) {
+            return !isDefiniteMatch;
+        }
+        if (isPlausibleMatch) {
+            // If this is a tuple, we can narrow it to a specific tuple type.
+            // Other sequences cannot be narrowed because we don't know if they
+            // are immutable (covariant).
+            if (canNarrowTuple) {
+                const tupleClassType = evaluator.getBuiltInType(pattern, 'tuple');
+                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    entry.subtype = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, narrowedEntryTypes.map((t) => {
+                        return { type: t, isUnbounded: false };
+                    })));
+                }
+            }
+            // If this is an object, we can narrow it to a specific Sequence type.
+            if (entry.isObject) {
+                const sequenceType = evaluator.getTypingType(pattern, 'Sequence');
+                if (sequenceType && (0, types_1.isInstantiableClass)(sequenceType)) {
+                    entry.subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(sequenceType, [(0, typeUtils_1.stripLiteralValue)((0, types_1.combineTypes)(narrowedEntryTypes))], 
+                    /* isTypeArgumentExplicit */ true));
+                }
+            }
+        }
+        return isPlausibleMatch;
+    });
+    return (0, types_1.combineTypes)(sequenceInfo.map((entry) => entry.subtype));
+}
+function narrowTypeBasedOnAsPattern(evaluator, type, pattern, isPositiveTest) {
+    let remainingType = type;
+    if (!isPositiveTest) {
+        pattern.orPatterns.forEach((subpattern) => {
+            remainingType = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, /* isPositiveTest */ false);
+        });
+        return remainingType;
+    }
+    const narrowedTypes = pattern.orPatterns.map((subpattern) => {
+        const narrowedSubtype = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, 
+        /* isPositiveTest */ true);
+        remainingType = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, /* isPositiveTest */ false);
+        return narrowedSubtype;
+    });
+    return (0, types_1.combineTypes)(narrowedTypes);
+}
+function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTest) {
+    if (!isPositiveTest) {
+        // Never narrow in negative case.
+        return type;
+    }
+    let mappingInfo = getMappingPatternInfo(evaluator, type);
+    // Further narrow based on pattern entry types.
+    mappingInfo = mappingInfo.filter((mappingSubtypeInfo) => {
+        let isPlausibleMatch = true;
+        pattern.entries.forEach((mappingEntry) => {
+            if (mappingSubtypeInfo.typedDict) {
+                if (mappingEntry.nodeType === 71 /* PatternMappingKeyEntry */) {
+                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.keyPattern, isPositiveTest);
+                    if ((0, types_1.isNever)(narrowedKeyType)) {
+                        isPlausibleMatch = false;
+                    }
+                    const valueType = (0, typeUtils_1.mapSubtypes)(narrowedKeyType, (keySubtype) => {
+                        if ((0, types_1.isAnyOrUnknown)(keySubtype)) {
+                            return keySubtype;
+                        }
+                        if ((0, types_1.isClassInstance)(keySubtype) && types_1.ClassType.isBuiltIn(keySubtype, 'str')) {
+                            if (!(0, typeUtils_1.isLiteralType)(keySubtype)) {
+                                return types_1.UnknownType.create();
+                            }
+                            const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, mappingSubtypeInfo.typedDict);
+                            const valueEntry = tdEntries.get(keySubtype.literalValue);
+                            if (valueEntry) {
+                                const narrowedValueType = narrowTypeBasedOnPattern(evaluator, valueEntry.valueType, mappingEntry.valuePattern, 
+                                /* isPositiveTest */ true);
+                                if (!(0, types_1.isNever)(narrowedValueType)) {
+                                    return narrowedValueType;
+                                }
+                            }
+                        }
+                        return undefined;
+                    });
+                    if ((0, types_1.isNever)(valueType)) {
+                        isPlausibleMatch = false;
+                    }
+                }
+            }
+            else if (mappingSubtypeInfo.dictTypeArgs) {
+                if (mappingEntry.nodeType === 71 /* PatternMappingKeyEntry */) {
+                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.keyPattern, isPositiveTest);
+                    const narrowedValueType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.valuePattern, isPositiveTest);
+                    if ((0, types_1.isNever)(narrowedKeyType) || (0, types_1.isNever)(narrowedValueType)) {
+                        isPlausibleMatch = false;
+                    }
+                }
+            }
+        });
+        return isPlausibleMatch;
+    });
+    return (0, types_1.combineTypes)(mappingInfo.map((entry) => entry.subtype));
+}
+// Looks up the "__match_args__" class member to determine the names of
+// the attributes used for class pattern matching.
+function getPositionalMatchArgNames(evaluator, type) {
+    const matchArgsMemberInfo = (0, typeUtils_1.lookUpClassMember)(type, '__match_args__');
+    if (matchArgsMemberInfo) {
+        const matchArgsType = evaluator.getTypeOfMember(matchArgsMemberInfo);
+        if ((0, types_1.isClassInstance)(matchArgsType) &&
+            (0, typeUtils_1.isTupleClass)(matchArgsType) &&
+            !(0, typeUtils_1.isUnboundedTupleClass)(matchArgsType) &&
+            matchArgsType.tupleTypeArguments) {
+            const tupleArgs = matchArgsType.tupleTypeArguments;
+            // Are all the args string literals?
+            if (tupleArgs.every((arg) => (0, types_1.isClassInstance)(arg.type) && types_1.ClassType.isBuiltIn(arg.type, 'str') && (0, typeUtils_1.isLiteralType)(arg.type))) {
+                return tupleArgs.map((arg) => arg.type.literalValue);
+            }
+        }
+    }
+    return [];
+}
+function narrowTypeBasedOnLiteralPattern(evaluator, type, pattern, isPositiveTest) {
+    const literalType = evaluator.getTypeOfExpression(pattern.expression).type;
+    if (!isPositiveTest) {
+        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(literalType) &&
+                (0, typeUtils_1.isLiteralType)(literalType) &&
+                (0, types_1.isClassInstance)(subtype) &&
+                (0, typeUtils_1.isLiteralType)(subtype) &&
+                evaluator.assignType(literalType, subtype)) {
+                return undefined;
+            }
+            if ((0, types_1.isNoneInstance)(subtype) && (0, types_1.isNoneInstance)(literalType)) {
+                return undefined;
+            }
+            // Narrow a non-literal bool based on a literal bool pattern.
+            if ((0, types_1.isClassInstance)(subtype) &&
+                types_1.ClassType.isBuiltIn(subtype, 'bool') &&
+                subtype.literalValue === undefined &&
+                (0, types_1.isClassInstance)(literalType) &&
+                types_1.ClassType.isBuiltIn(literalType, 'bool') &&
+                literalType.literalValue !== undefined) {
+                return types_1.ClassType.cloneWithLiteral(literalType, !literalType.literalValue);
+            }
+            return subtype;
+        });
+    }
+    return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        if (evaluator.assignType(subtype, literalType)) {
+            return literalType;
+        }
+        return undefined;
+    });
+}
+function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest) {
+    let exprType = evaluator.getTypeOfExpression(pattern.className, 2 /* DoNotSpecialize */).type;
+    // If this is a class (but not a type alias that refers to a class),
+    // specialize it with Unknown type arguments.
+    if ((0, types_1.isClass)(exprType) && !exprType.typeAliasInfo) {
+        exprType = (0, typeUtils_1.specializeClassType)(exprType);
+    }
+    if (!isPositiveTest) {
+        // Don't attempt to narrow if the class type is a more complex type (e.g. a TypeVar or union).
+        if (!(0, types_1.isInstantiableClass)(exprType)) {
+            return type;
+        }
+        let classType = exprType;
+        if (classType.details.typeParameters.length > 0) {
+            classType = types_1.ClassType.cloneForSpecialization(classType, 
+            /* typeArguments */ undefined, 
+            /* isTypeArgumentExplicit */ false);
+        }
+        const classInstance = (0, typeUtils_1.convertToInstance)(classType);
+        return evaluator.mapSubtypesExpandTypeVars(type, 
+        /* conditionFilter */ undefined, (subjectSubtypeExpanded, subjectSubtypeUnexpanded) => {
+            if (!(0, types_1.isClassInstance)(subjectSubtypeExpanded)) {
+                return subjectSubtypeUnexpanded;
+            }
+            if (!evaluator.assignType(classInstance, subjectSubtypeExpanded)) {
+                return subjectSubtypeExpanded;
+            }
+            // If there are no arguments, we're done. We know that this match
+            // will never succeed.
+            if (pattern.arguments.length === 0) {
+                return undefined;
+            }
+            // We might be able to narrow further based on arguments, but only
+            // if the types match exactly or the subtype is a final class and
+            // therefore cannot be subclassed.
+            if (!evaluator.assignType(subjectSubtypeExpanded, classInstance)) {
+                if (!types_1.ClassType.isFinal(subjectSubtypeExpanded)) {
+                    return subjectSubtypeExpanded;
+                }
+            }
+            // Are there any positional arguments? If so, try to get the mappings for
+            // these arguments by fetching the __match_args__ symbol from the class.
+            let positionalArgNames = [];
+            if (pattern.arguments.some((arg) => !arg.name)) {
+                if ((0, types_1.isClass)(subjectSubtypeExpanded)) {
+                    positionalArgNames = getPositionalMatchArgNames(evaluator, subjectSubtypeExpanded);
+                }
+            }
+            for (let index = 0; index < pattern.arguments.length; index++) {
+                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, pattern.arguments[index], index, positionalArgNames, subjectSubtypeExpanded, isPositiveTest);
+                if (!(0, types_1.isNever)(narrowedArgType)) {
+                    return subjectSubtypeUnexpanded;
+                }
+            }
+            // We've completely eliminated the type based on the arguments.
+            return undefined;
+        });
+    }
+    if (!types_1.TypeBase.isInstantiable(exprType) && !(0, types_1.isNever)(exprType)) {
+        evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(pattern).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.DiagnosticAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.className);
+        return types_1.NeverType.createNever();
+    }
+    return evaluator.mapSubtypesExpandTypeVars(exprType, 
+    /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
+        if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
+            return unexpandedSubtype;
+        }
+        if ((0, types_1.isInstantiableClass)(expandedSubtype)) {
+            return evaluator.mapSubtypesExpandTypeVars(type, 
+            /* conditionFilter */ undefined, (subjectSubtypeExpanded) => {
+                if ((0, types_1.isAnyOrUnknown)(subjectSubtypeExpanded)) {
+                    return (0, typeUtils_1.convertToInstance)(unexpandedSubtype);
+                }
+                if ((0, types_1.isClassInstance)(subjectSubtypeExpanded)) {
+                    let resultType;
+                    if (evaluator.assignType(expandedSubtype, types_1.ClassType.cloneAsInstantiable(subjectSubtypeExpanded))) {
+                        resultType = subjectSubtypeExpanded;
+                    }
+                    else if (evaluator.assignType(types_1.ClassType.cloneAsInstantiable(subjectSubtypeExpanded), expandedSubtype)) {
+                        resultType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.convertToInstance)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subjectSubtypeExpanded));
+                        // Try to retain the type arguments for the pattern class type.
+                        if ((0, types_1.isInstantiableClass)(unexpandedSubtype) && (0, types_1.isClassInstance)(subjectSubtypeExpanded)) {
+                            if (types_1.ClassType.isSpecialBuiltIn(unexpandedSubtype) ||
+                                unexpandedSubtype.details.typeParameters.length > 0) {
+                                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(unexpandedSubtype));
+                                const unspecializedMatchType = types_1.ClassType.cloneForSpecialization(unexpandedSubtype, 
+                                /* typeArguments */ undefined, 
+                                /* isTypeArgumentExplicit */ false);
+                                const matchTypeInstance = types_1.ClassType.cloneAsInstance(unspecializedMatchType);
+                                if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, matchTypeInstance, subjectSubtypeExpanded, typeVarContext, [])) {
+                                    resultType = (0, typeUtils_1.applySolvedTypeVars)(matchTypeInstance, typeVarContext, 
+                                    /* unknownIfNotFound */ true);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        return undefined;
+                    }
+                    // Are there any positional arguments? If so, try to get the mappings for
+                    // these arguments by fetching the __match_args__ symbol from the class.
+                    let positionalArgNames = [];
+                    if (pattern.arguments.some((arg) => !arg.name)) {
+                        positionalArgNames = getPositionalMatchArgNames(evaluator, expandedSubtype);
+                    }
+                    let isMatchValid = true;
+                    pattern.arguments.forEach((arg, index) => {
+                        // Narrow the arg pattern. It's possible that the actual type of the object
+                        // being matched is a subtype of the resultType, so it might contain additional
+                        // attributes that we don't know about.
+                        const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, arg, index, positionalArgNames, resultType, isPositiveTest);
+                        if ((0, types_1.isNever)(narrowedArgType)) {
+                            isMatchValid = false;
+                        }
+                    });
+                    if (isMatchValid) {
+                        return resultType;
+                    }
+                }
+                return undefined;
+            });
+        }
+        return undefined;
+    });
+}
+// Narrows the pattern provided for a class pattern argument.
+function narrowTypeOfClassPatternArgument(evaluator, arg, argIndex, positionalArgNames, matchType, isPositiveTest) {
+    var _a;
+    let argName;
+    if (arg.name) {
+        argName = arg.name.value;
+    }
+    else if (argIndex < positionalArgNames.length) {
+        argName = positionalArgNames[argIndex];
+    }
+    if ((0, types_1.isAnyOrUnknown)(matchType)) {
+        return matchType;
+    }
+    if (!(0, types_1.isClass)(matchType)) {
+        return types_1.UnknownType.create();
+    }
+    const useSelfForPattern = (0, types_1.isClass)(matchType) &&
+        classPatternSpecialCases.some((className) => matchType.details.fullName === className) &&
+        argIndex === 0 &&
+        !arg.name;
+    let argType;
+    if (useSelfForPattern) {
+        argType = types_1.ClassType.cloneAsInstance(matchType);
+    }
+    else {
+        if (argName) {
+            argType = (_a = evaluator.useSpeculativeMode(arg, () => 
+            // We need to apply a rather ugly cast here because PatternClassArgumentNode is
+            // not technically an ExpressionNode, but it is OK to use it in this context.
+            evaluator.getTypeOfObjectMember(arg, types_1.ClassType.cloneAsInstance(matchType), argName))) === null || _a === void 0 ? void 0 : _a.type;
+        }
+        if (!argType) {
+            if (!isPositiveTest) {
+                return matchType;
+            }
+            // If the class type in question is "final", we know that no additional
+            // attributes can be added by subtypes, so it's safe to eliminate this
+            // type entirely.
+            if (types_1.ClassType.isFinal(matchType)) {
+                return types_1.NeverType.createNever();
+            }
+            argType = types_1.UnknownType.create();
+        }
+    }
+    return narrowTypeBasedOnPattern(evaluator, argType, arg.pattern, isPositiveTest);
+}
+function narrowTypeBasedOnValuePattern(evaluator, subjectType, pattern, isPositiveTest) {
+    const valueType = evaluator.getTypeOfExpression(pattern.expression).type;
+    const narrowedSubtypes = [];
+    evaluator.mapSubtypesExpandTypeVars(valueType, 
+    /* conditionFilter */ undefined, (valueSubtypeExpanded, valueSubtypeUnexpanded) => {
+        narrowedSubtypes.push(evaluator.mapSubtypesExpandTypeVars(subjectType, (0, typeUtils_1.getTypeCondition)(valueSubtypeExpanded), (subjectSubtypeExpanded) => {
+            // If this is a negative test, see if it's an enum value.
+            if (!isPositiveTest) {
+                if ((0, types_1.isClassInstance)(subjectSubtypeExpanded) &&
+                    types_1.ClassType.isEnumClass(subjectSubtypeExpanded) &&
+                    !(0, typeUtils_1.isLiteralType)(subjectSubtypeExpanded) &&
+                    (0, types_1.isClassInstance)(valueSubtypeExpanded) &&
+                    (0, types_1.isSameWithoutLiteralValue)(subjectSubtypeExpanded, valueSubtypeExpanded) &&
+                    (0, typeUtils_1.isLiteralType)(valueSubtypeExpanded)) {
+                    const allEnumTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluator, subjectSubtypeExpanded);
+                    if (allEnumTypes) {
+                        return (0, types_1.combineTypes)(allEnumTypes.filter((enumType) => !types_1.ClassType.isLiteralValueSame(valueSubtypeExpanded, enumType)));
+                    }
+                }
+                else if ((0, types_1.isClassInstance)(subjectSubtypeExpanded) &&
+                    (0, types_1.isClassInstance)(valueSubtypeExpanded) &&
+                    types_1.ClassType.isLiteralValueSame(valueSubtypeExpanded, subjectSubtypeExpanded)) {
+                    return undefined;
+                }
+                return subjectSubtypeExpanded;
+            }
+            if ((0, types_1.isNever)(valueSubtypeExpanded) || (0, types_1.isNever)(subjectSubtypeExpanded)) {
+                return types_1.NeverType.createNever();
+            }
+            if ((0, types_1.isAnyOrUnknown)(valueSubtypeExpanded) || (0, types_1.isAnyOrUnknown)(subjectSubtypeExpanded)) {
+                // If either type is "Unknown" (versus Any), propagate the Unknown.
+                return (0, types_1.isUnknown)(valueSubtypeExpanded) || (0, types_1.isUnknown)(subjectSubtypeExpanded)
+                    ? types_1.UnknownType.create()
+                    : types_1.AnyType.create();
+            }
+            // Determine if we assignment is supported for this combination of
+            // value subtype and matching subtype.
+            const returnType = evaluator.useSpeculativeMode(pattern.expression, () => evaluator.getTypeOfMagicMethodReturn(valueSubtypeExpanded, [subjectSubtypeExpanded], '__eq__', pattern.expression, 
+            /* expectedType */ undefined));
+            return returnType ? valueSubtypeUnexpanded : undefined;
+        }));
+        return undefined;
+    });
+    return (0, types_1.combineTypes)(narrowedSubtypes);
+}
+// Returns information about all subtypes that match the definition of a "mapping" as
+// specified in PEP 634.
+function getMappingPatternInfo(evaluator, type) {
+    const mappingInfo = [];
+    (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+        const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+            mappingInfo.push({
+                subtype,
+                dictTypeArgs: {
+                    key: concreteSubtype,
+                    value: concreteSubtype,
+                },
+            });
+        }
+        else if ((0, types_1.isClassInstance)(concreteSubtype)) {
+            if (types_1.ClassType.isTypedDictClass(concreteSubtype)) {
+                mappingInfo.push({
+                    subtype,
+                    typedDict: concreteSubtype,
+                });
+            }
+            else {
+                let mroClassToSpecialize;
+                for (const mroClass of concreteSubtype.details.mro) {
+                    if ((0, types_1.isInstantiableClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'Mapping')) {
+                        mroClassToSpecialize = mroClass;
+                        break;
+                    }
+                }
+                if (mroClassToSpecialize) {
+                    const specializedMapping = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype);
+                    if (specializedMapping.typeArguments && specializedMapping.typeArguments.length >= 2) {
+                        mappingInfo.push({
+                            subtype,
+                            dictTypeArgs: {
+                                key: specializedMapping.typeArguments[0],
+                                value: specializedMapping.typeArguments[1],
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return mappingInfo;
+}
+// Returns information about all subtypes that match the definition of a "sequence" as
+// specified in PEP 634. For types that are not sequences or sequences that are not of
+// sufficient length, it sets definiteNoMatch to true.
+function getSequencePatternInfo(evaluator, type, entryCount, starEntryIndex) {
+    const sequenceInfo = [];
+    const minEntryCount = starEntryIndex === undefined ? entryCount : entryCount - 1;
+    (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+        const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
+        let mroClassToSpecialize;
+        let pushedEntry = false;
+        if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+            sequenceInfo.push({
+                subtype,
+                entryTypes: [concreteSubtype],
+                isIndeterminateLength: true,
+                definiteNoMatch: false,
+            });
+            return;
+        }
+        if ((0, types_1.isClassInstance)(concreteSubtype)) {
+            if (types_1.ClassType.isBuiltIn(concreteSubtype, 'object')) {
+                sequenceInfo.push({
+                    subtype,
+                    entryTypes: [(0, typeUtils_1.convertToInstance)(concreteSubtype)],
+                    isIndeterminateLength: true,
+                    isObject: true,
+                    definiteNoMatch: false,
+                });
+                return;
+            }
+            for (const mroClass of concreteSubtype.details.mro) {
+                if (!(0, types_1.isInstantiableClass)(mroClass)) {
+                    break;
+                }
+                // Strings, bytes, and bytearray are explicitly excluded.
+                if (types_1.ClassType.isBuiltIn(mroClass, 'str') ||
+                    types_1.ClassType.isBuiltIn(mroClass, 'bytes') ||
+                    types_1.ClassType.isBuiltIn(mroClass, 'bytearray')) {
+                    break;
+                }
+                if (types_1.ClassType.isBuiltIn(mroClass, 'Sequence')) {
+                    mroClassToSpecialize = mroClass;
+                    break;
+                }
+                if ((0, typeUtils_1.isTupleClass)(mroClass)) {
+                    mroClassToSpecialize = mroClass;
+                    break;
+                }
+            }
+            if (mroClassToSpecialize) {
+                const specializedSequence = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype);
+                if ((0, typeUtils_1.isTupleClass)(specializedSequence)) {
+                    if (specializedSequence.tupleTypeArguments) {
+                        if ((0, typeUtils_1.isUnboundedTupleClass)(specializedSequence)) {
+                            sequenceInfo.push({
+                                subtype,
+                                entryTypes: [(0, types_1.combineTypes)(specializedSequence.tupleTypeArguments.map((t) => t.type))],
+                                isIndeterminateLength: true,
+                                isTuple: true,
+                                definiteNoMatch: false,
+                            });
+                            pushedEntry = true;
+                        }
+                        else {
+                            if (specializedSequence.tupleTypeArguments.length >= minEntryCount &&
+                                (starEntryIndex !== undefined ||
+                                    specializedSequence.tupleTypeArguments.length === minEntryCount)) {
+                                sequenceInfo.push({
+                                    subtype,
+                                    entryTypes: specializedSequence.tupleTypeArguments.map((t) => t.type),
+                                    isIndeterminateLength: false,
+                                    isTuple: true,
+                                    definiteNoMatch: false,
+                                });
+                                pushedEntry = true;
+                            }
+                        }
+                    }
+                }
+                else {
+                    sequenceInfo.push({
+                        subtype,
+                        entryTypes: [
+                            specializedSequence.typeArguments && specializedSequence.typeArguments.length > 0
+                                ? specializedSequence.typeArguments[0]
+                                : types_1.UnknownType.create(),
+                        ],
+                        isIndeterminateLength: true,
+                        definiteNoMatch: false,
+                    });
+                    pushedEntry = true;
+                }
+            }
+        }
+        // Push an entry that indicates that this is definitely not a match.
+        if (!pushedEntry) {
+            sequenceInfo.push({
+                subtype,
+                entryTypes: [],
+                isIndeterminateLength: true,
+                definiteNoMatch: true,
+            });
+        }
+    });
+    return sequenceInfo;
+}
+function getTypeOfPatternSequenceEntry(evaluator, node, sequenceInfo, entryIndex, entryCount, starEntryIndex, unpackStarEntry, isSubjectObject) {
+    if (sequenceInfo.isIndeterminateLength) {
+        let entryType = sequenceInfo.entryTypes[0];
+        // If the subject is typed as an "object", then the star entry
+        // is simply a list[object]. Without this special case, the list
+        // will be typed based on the union of all elements in the sequence.
+        if (isSubjectObject) {
+            const objectType = evaluator.getBuiltInObject(node, 'object');
+            if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                entryType = objectType;
+            }
+        }
+        if (!unpackStarEntry && entryIndex === starEntryIndex && !(0, types_1.isNever)(entryType)) {
+            entryType = wrapTypeInList(evaluator, node, entryType);
+        }
+        return entryType;
+    }
+    if (starEntryIndex === undefined || entryIndex < starEntryIndex) {
+        return sequenceInfo.entryTypes[entryIndex];
+    }
+    if (entryIndex === starEntryIndex) {
+        // Create a list out of the entries that map to the star entry.
+        // Note that we strip literal types here.
+        const starEntryTypes = sequenceInfo.entryTypes
+            .slice(starEntryIndex, starEntryIndex + sequenceInfo.entryTypes.length - entryCount + 1)
+            .map((type) => (0, typeUtils_1.stripLiteralValue)(type));
+        let entryType = (0, types_1.combineTypes)(starEntryTypes);
+        if (!unpackStarEntry) {
+            entryType = wrapTypeInList(evaluator, node, entryType);
+        }
+        return entryType;
+    }
+    // The entry index is past the index of the star entry, so we need
+    // to index from the end of the sequence rather than the start.
+    const itemIndex = sequenceInfo.entryTypes.length - (entryCount - entryIndex);
+    (0, debug_1.assert)(itemIndex >= 0 && itemIndex < sequenceInfo.entryTypes.length);
+    return sequenceInfo.entryTypes[itemIndex];
+}
+// Recursively assigns the specified type to the pattern and any capture
+// nodes within it
+function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, isSubjectObject, pattern) {
+    // Further narrow the type based on this pattern.
+    type = narrowTypeBasedOnPattern(evaluator, type, pattern, /* positiveTest */ true);
+    switch (pattern.nodeType) {
+        case 65 /* PatternSequence */: {
+            const sequenceInfo = getSequencePatternInfo(evaluator, type, pattern.entries.length, pattern.starEntryIndex).filter((seqInfo) => !seqInfo.definiteNoMatch);
+            pattern.entries.forEach((entry, index) => {
+                const entryType = (0, types_1.combineTypes)(sequenceInfo.map((info) => getTypeOfPatternSequenceEntry(evaluator, pattern, info, index, pattern.entries.length, pattern.starEntryIndex, 
+                /* unpackStarEntry */ false, isSubjectObject)));
+                assignTypeToPatternTargets(evaluator, entryType, isTypeIncomplete, /* isSubjectObject */ false, entry);
+            });
+            break;
+        }
+        case 66 /* PatternAs */: {
+            if (pattern.target) {
+                evaluator.assignTypeToExpression(pattern.target, type, isTypeIncomplete, pattern.target);
+            }
+            pattern.orPatterns.forEach((orPattern) => {
+                assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, isSubjectObject, orPattern);
+                // OR patterns are evaluated left to right, so we can narrow
+                // the type as we go.
+                type = narrowTypeBasedOnPattern(evaluator, type, orPattern, /* positiveTest */ false);
+            });
+            break;
+        }
+        case 69 /* PatternCapture */: {
+            evaluator.assignTypeToExpression(pattern.target, pattern.isWildcard ? types_1.AnyType.create() : type, isTypeIncomplete, pattern.target);
+            break;
+        }
+        case 70 /* PatternMapping */: {
+            const mappingInfo = getMappingPatternInfo(evaluator, type);
+            pattern.entries.forEach((mappingEntry) => {
+                const keyTypes = [];
+                const valueTypes = [];
+                mappingInfo.forEach((mappingSubtypeInfo) => {
+                    if (mappingSubtypeInfo.typedDict) {
+                        if (mappingEntry.nodeType === 71 /* PatternMappingKeyEntry */) {
+                            const keyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.keyPattern, 
+                            /* isPositiveTest */ true);
+                            keyTypes.push(keyType);
+                            (0, typeUtils_1.doForEachSubtype)(keyType, (keySubtype) => {
+                                if ((0, types_1.isClassInstance)(keySubtype) &&
+                                    types_1.ClassType.isBuiltIn(keySubtype, 'str') &&
+                                    (0, typeUtils_1.isLiteralType)(keySubtype)) {
+                                    const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, mappingSubtypeInfo.typedDict);
+                                    const valueInfo = tdEntries.get(keySubtype.literalValue);
+                                    valueTypes.push(valueInfo ? valueInfo.valueType : types_1.UnknownType.create());
+                                }
+                                else {
+                                    valueTypes.push(types_1.UnknownType.create());
+                                }
+                            });
+                        }
+                        else if (mappingEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                            keyTypes.push(evaluator.getBuiltInObject(pattern, 'str'));
+                            valueTypes.push(types_1.UnknownType.create());
+                        }
+                    }
+                    else if (mappingSubtypeInfo.dictTypeArgs) {
+                        if (mappingEntry.nodeType === 71 /* PatternMappingKeyEntry */) {
+                            const keyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.keyPattern, 
+                            /* isPositiveTest */ true);
+                            keyTypes.push(keyType);
+                            valueTypes.push(narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.valuePattern, 
+                            /* isPositiveTest */ true));
+                        }
+                        else if (mappingEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                            keyTypes.push(mappingSubtypeInfo.dictTypeArgs.key);
+                            valueTypes.push(mappingSubtypeInfo.dictTypeArgs.value);
+                        }
+                    }
+                });
+                const keyType = (0, types_1.combineTypes)(keyTypes);
+                const valueType = (0, types_1.combineTypes)(valueTypes);
+                if (mappingEntry.nodeType === 71 /* PatternMappingKeyEntry */) {
+                    assignTypeToPatternTargets(evaluator, keyType, isTypeIncomplete, 
+                    /* isSubjectObject */ false, mappingEntry.keyPattern);
+                    assignTypeToPatternTargets(evaluator, valueType, isTypeIncomplete, 
+                    /* isSubjectObject */ false, mappingEntry.valuePattern);
+                }
+                else if (mappingEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                    const dictClass = evaluator.getBuiltInType(pattern, 'dict');
+                    const strType = evaluator.getBuiltInObject(pattern, 'str');
+                    const dictType = dictClass && (0, types_1.isInstantiableClass)(dictClass) && (0, types_1.isClassInstance)(strType)
+                        ? types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictClass, [keyType, valueType], 
+                        /* isTypeArgumentExplicit */ true))
+                        : types_1.UnknownType.create();
+                    evaluator.assignTypeToExpression(mappingEntry.target, dictType, isTypeIncomplete, mappingEntry.target);
+                }
+            });
+            break;
+        }
+        case 68 /* PatternClass */: {
+            const argTypes = pattern.arguments.map((arg) => []);
+            evaluator.mapSubtypesExpandTypeVars(type, /* conditionFilter */ undefined, (expandedSubtype) => {
+                if ((0, types_1.isClassInstance)(expandedSubtype)) {
+                    (0, typeUtils_1.doForEachSubtype)(type, (subjectSubtype) => {
+                        const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subjectSubtype);
+                        if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+                            pattern.arguments.forEach((arg, index) => {
+                                argTypes[index].push(concreteSubtype);
+                            });
+                        }
+                        else if ((0, types_1.isClassInstance)(concreteSubtype)) {
+                            // Are there any positional arguments? If so, try to get the mappings for
+                            // these arguments by fetching the __match_args__ symbol from the class.
+                            let positionalArgNames = [];
+                            if (pattern.arguments.some((arg) => !arg.name)) {
+                                positionalArgNames = getPositionalMatchArgNames(evaluator, types_1.ClassType.cloneAsInstantiable(expandedSubtype));
+                            }
+                            pattern.arguments.forEach((arg, index) => {
+                                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, arg, index, positionalArgNames, types_1.ClassType.cloneAsInstantiable(expandedSubtype), 
+                                /* isPositiveTest */ true);
+                                argTypes[index].push(narrowedArgType);
+                            });
+                        }
+                    });
+                }
+                else {
+                    pattern.arguments.forEach((arg, index) => {
+                        argTypes[index].push(types_1.UnknownType.create());
+                    });
+                }
+                return undefined;
+            });
+            pattern.arguments.forEach((arg, index) => {
+                assignTypeToPatternTargets(evaluator, (0, types_1.combineTypes)(argTypes[index]), isTypeIncomplete, 
+                /* isSubjectObject */ false, arg.pattern);
+            });
+            break;
+        }
+        case 67 /* PatternLiteral */:
+        case 73 /* PatternValue */:
+        case 0 /* Error */: {
+            // Nothing to do here.
+            break;
+        }
+    }
+}
+exports.assignTypeToPatternTargets = assignTypeToPatternTargets;
+function wrapTypeInList(evaluator, node, type) {
+    if ((0, types_1.isNever)(type)) {
+        return type;
+    }
+    const listObjectType = (0, typeUtils_1.convertToInstance)(evaluator.getBuiltInObject(node, 'list'));
+    if (listObjectType && (0, types_1.isClassInstance)(listObjectType)) {
+        return types_1.ClassType.cloneForSpecialization(listObjectType, [type], /* isTypeArgumentExplicit */ true);
+    }
+    return types_1.UnknownType.create();
+}
+function validateClassPattern(evaluator, pattern) {
+    const exprType = evaluator.getTypeOfExpression(pattern.className, 2 /* DoNotSpecialize */).type;
+    if ((0, types_1.isAnyOrUnknown)(exprType)) {
+        return;
+    }
+    // Check for certain uses of type aliases that generate runtime exceptions.
+    if (exprType.typeAliasInfo &&
+        (0, types_1.isInstantiableClass)(exprType) &&
+        exprType.typeArguments &&
+        exprType.isTypeArgumentExplicit) {
+        evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(pattern).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classPatternTypeAlias().format({ type: evaluator.printType(exprType) }), pattern.className);
+    }
+    else if (!(0, types_1.isInstantiableClass)(exprType)) {
+        if (!(0, types_1.isNever)(exprType)) {
+            evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(pattern).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.DiagnosticAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.className);
+        }
+    }
+    else {
+        const isBuiltIn = classPatternSpecialCases.some((className) => exprType.details.fullName === className);
+        // If it's a special-case builtin class, only one positional argument is allowed.
+        if (isBuiltIn) {
+            if (pattern.arguments.length > 1) {
+                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(pattern).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classPatternBuiltInArgCount(), pattern.arguments[1]);
+            }
+            else if (pattern.arguments.length === 1 && pattern.arguments[0].name) {
+                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(pattern).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classPatternBuiltInArgPositional(), pattern.arguments[0].name);
+            }
+        }
+    }
+}
+exports.validateClassPattern = validateClassPattern;
+//# sourceMappingURL=patternMatching.js.map