@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/analyzer/patternMatching.js

@@ -74,9 +74,9 @@ function checkForUnusedPattern(evaluator, pattern, subjectType) {
     if ((0, types_1.isNever)(subjectType)) {
         reportUnnecessaryPattern(evaluator, pattern, subjectType);
     }
-    else if (pattern.nodeType === 66 /* ParseNodeType.PatternAs */ && pattern.orPatterns.length > 1) {
+    else if (pattern.nodeType === 66 /* ParseNodeType.PatternAs */ && pattern.d.orPatterns.length > 1) {
         // Check each of the or patterns separately.
-        pattern.orPatterns.forEach((orPattern) => {
+        pattern.d.orPatterns.forEach((orPattern) => {
             const subjectTypeMatch = narrowTypeBasedOnPattern(evaluator, subjectType, orPattern, 
             /* isPositiveTest */ true);
             if ((0, types_1.isNever)(subjectTypeMatch)) {
@@ -118,32 +118,38 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
             if (entry.isIndeterminateLength) {
                 canNarrowTuple = false;
             }
-            if ((0, types_1.isClassInstance)(entry.subtype) &&
-                entry.subtype.tupleTypeArguments &&
-                entry.subtype.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
-                canNarrowTuple = false;
+            if ((0, types_1.isClassInstance)(entry.subtype) && entry.subtype.priv.tupleTypeArguments) {
+                const unboundedIndex = entry.subtype.priv.tupleTypeArguments.findIndex((typeArg) => typeArg.isUnbounded);
+                if (unboundedIndex >= 0) {
+                    // If the pattern includes a "star" entry that aligns exactly with
+                    // the corresponding unbounded entry in the tuple, we can narrow
+                    // the tuple type.
+                    if (pattern.d.starEntryIndex === undefined || pattern.d.starEntryIndex !== unboundedIndex) {
+                        canNarrowTuple = false;
+                    }
+                }
             }
         }
         // 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) {
+            if (pattern.d.entries.length !== 1 || pattern.d.starEntryIndex !== 0) {
                 isDefiniteMatch = false;
             }
         }
         let negativeEntriesNarrowed = 0;
-        pattern.entries.forEach((sequenceEntry, index) => {
-            const entryType = getTypeOfPatternSequenceEntry(evaluator, pattern, entry, index, pattern.entries.length, pattern.starEntryIndex, 
+        pattern.d.entries.forEach((sequenceEntry, index) => {
+            const entryType = getTypeOfPatternSequenceEntry(evaluator, pattern, entry, index, pattern.d.entries.length, pattern.d.starEntryIndex, 
             /* unpackStarEntry */ true);
             const narrowedEntryType = narrowTypeBasedOnPattern(evaluator, entryType, sequenceEntry, isPositiveTest);
             if (isPositiveTest) {
-                if (index === pattern.starEntryIndex) {
+                if (index === pattern.d.starEntryIndex) {
                     if ((0, types_1.isClassInstance)(narrowedEntryType) &&
-                        narrowedEntryType.tupleTypeArguments &&
+                        narrowedEntryType.priv.tupleTypeArguments &&
                         !(0, typeUtils_1.isUnboundedTupleClass)(narrowedEntryType) &&
-                        narrowedEntryType.tupleTypeArguments) {
-                        (0, collectionUtils_1.appendArray)(narrowedEntryTypes, narrowedEntryType.tupleTypeArguments.map((t) => t.type));
+                        narrowedEntryType.priv.tupleTypeArguments) {
+                        (0, collectionUtils_1.appendArray)(narrowedEntryTypes, narrowedEntryType.priv.tupleTypeArguments.map((t) => t.type));
                     }
                     else {
                         narrowedEntryTypes.push(narrowedEntryType);
@@ -172,12 +178,12 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
                 else {
                     narrowedEntryTypes.push(entryType);
                 }
-                if (index === pattern.starEntryIndex) {
+                if (index === pattern.d.starEntryIndex) {
                     canNarrowTuple = false;
                 }
             }
         });
-        if (pattern.entries.length === 0) {
+        if (pattern.d.entries.length === 0) {
             // If the pattern is an empty sequence, use the entry types.
             if (entry.entryTypes.length > 0) {
                 narrowedEntryTypes.push((0, types_1.combineTypes)(entry.entryTypes));
@@ -234,12 +240,12 @@ function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTe
 function narrowTypeBasedOnAsPattern(evaluator, type, pattern, isPositiveTest) {
     let remainingType = type;
     if (!isPositiveTest) {
-        pattern.orPatterns.forEach((subpattern) => {
+        pattern.d.orPatterns.forEach((subpattern) => {
             remainingType = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, /* isPositiveTest */ false);
         });
         return remainingType;
     }
-    const narrowedTypes = pattern.orPatterns.map((subpattern) => {
+    const narrowedTypes = pattern.d.orPatterns.map((subpattern) => {
         const narrowedSubtype = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, 
         /* isPositiveTest */ true);
         remainingType = narrowTypeBasedOnPattern(evaluator, remainingType, subpattern, /* isPositiveTest */ false);
@@ -250,26 +256,33 @@ function narrowTypeBasedOnAsPattern(evaluator, type, pattern, isPositiveTest) {
 function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTest) {
     type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
     if (!isPositiveTest) {
-        // Our ability to narrow in the negative case for mapping patterns is
-        // limited, but we can do it if the type is a union that includes a
-        // TypedDict with a field discriminated by a literal.
-        if (pattern.entries.length !== 1 || pattern.entries[0].nodeType !== 71 /* ParseNodeType.PatternMappingKeyEntry */) {
+        // Handle the case where the pattern consists only of a "**x" entry.
+        if (pattern.d.entries.length === 1 &&
+            pattern.d.entries[0].nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
+            const mappingInfo = getMappingPatternInfo(evaluator, type, pattern);
+            return (0, types_1.combineTypes)(mappingInfo.filter((m) => !m.isDefinitelyMapping).map((m) => m.subtype));
+        }
+        if (pattern.d.entries.length !== 1 || pattern.d.entries[0].nodeType !== 71 /* ParseNodeType.PatternMappingKeyEntry */) {
             return type;
         }
-        const keyPattern = pattern.entries[0].keyPattern;
-        const valuePattern = pattern.entries[0].valuePattern;
+        // Handle the case where the type is a union that includes a TypedDict with
+        // a field discriminated by a literal.
+        const keyPattern = pattern.d.entries[0].d.keyPattern;
+        const valuePattern = pattern.d.entries[0].d.valuePattern;
         if (keyPattern.nodeType !== 67 /* ParseNodeType.PatternLiteral */ ||
             valuePattern.nodeType !== 66 /* ParseNodeType.PatternAs */ ||
-            !valuePattern.orPatterns.every((orPattern) => orPattern.nodeType === 67 /* ParseNodeType.PatternLiteral */)) {
+            !valuePattern.d.orPatterns.every((orPattern) => orPattern.nodeType === 67 /* ParseNodeType.PatternLiteral */)) {
             return type;
         }
-        const keyType = evaluator.getTypeOfExpression(keyPattern.expression).type;
+        const keyType = evaluator.getTypeOfExpression(keyPattern.d.expr).type;
         // The key type must be a str literal.
-        if (!(0, types_1.isClassInstance)(keyType) || !types_1.ClassType.isBuiltIn(keyType, 'str') || keyType.literalValue === undefined) {
+        if (!(0, types_1.isClassInstance)(keyType) ||
+            !types_1.ClassType.isBuiltIn(keyType, 'str') ||
+            keyType.priv.literalValue === undefined) {
             return type;
         }
-        const keyValue = keyType.literalValue;
-        const valueTypes = valuePattern.orPatterns.map((orPattern) => evaluator.getTypeOfExpression(orPattern.expression).type);
+        const keyValue = keyType.priv.literalValue;
+        const valueTypes = valuePattern.d.orPatterns.map((orPattern) => evaluator.getTypeOfExpression(orPattern.d.expr).type);
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
                 const typedDictMembers = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
@@ -280,7 +293,7 @@ function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTes
                     // the literal type of the member, we can eliminate this type.
                     if (valueTypes.some((valueType) => (0, types_1.isClassInstance)(valueType) &&
                         types_1.ClassType.isSameGenericClass(valueType, memberValueType) &&
-                        valueType.literalValue === memberValueType.literalValue)) {
+                        valueType.priv.literalValue === memberValueType.priv.literalValue)) {
                         return undefined;
                     }
                 }
@@ -291,11 +304,14 @@ function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTes
     let mappingInfo = getMappingPatternInfo(evaluator, type, pattern);
     // Further narrow based on pattern entry types.
     mappingInfo = mappingInfo.filter((mappingSubtypeInfo) => {
+        if (mappingSubtypeInfo.isDefinitelyNotMapping) {
+            return false;
+        }
         let isPlausibleMatch = true;
-        pattern.entries.forEach((mappingEntry) => {
+        pattern.d.entries.forEach((mappingEntry) => {
             if (mappingSubtypeInfo.typedDict) {
                 if (mappingEntry.nodeType === 71 /* ParseNodeType.PatternMappingKeyEntry */) {
-                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.keyPattern, isPositiveTest);
+                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.d.keyPattern, isPositiveTest);
                     if ((0, types_1.isNever)(narrowedKeyType)) {
                         isPlausibleMatch = false;
                     }
@@ -309,9 +325,9 @@ function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTes
                                 return types_1.UnknownType.create();
                             }
                             const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, mappingSubtypeInfo.typedDict);
-                            const valueEntry = tdEntries.knownItems.get(keySubtype.literalValue);
+                            const valueEntry = tdEntries.knownItems.get(keySubtype.priv.literalValue);
                             if (valueEntry) {
-                                const narrowedValueType = narrowTypeBasedOnPattern(evaluator, valueEntry.valueType, mappingEntry.valuePattern, 
+                                const narrowedValueType = narrowTypeBasedOnPattern(evaluator, valueEntry.valueType, mappingEntry.d.valuePattern, 
                                 /* isPositiveTest */ true);
                                 if (!(0, types_1.isNever)(narrowedValueType)) {
                                     // If this is a "NotRequired" entry that has not yet been demonstrated
@@ -319,8 +335,8 @@ function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTes
                                     if (!valueEntry.isRequired &&
                                         !valueEntry.isProvided &&
                                         (0, types_1.isTypeSame)(mappingSubtypeInfo.subtype, mappingSubtypeInfo.typedDict)) {
-                                        const newNarrowedEntriesMap = new Map((_a = mappingSubtypeInfo.typedDict.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : []);
-                                        newNarrowedEntriesMap.set(keySubtype.literalValue, {
+                                        const newNarrowedEntriesMap = new Map((_a = mappingSubtypeInfo.typedDict.priv.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : []);
+                                        newNarrowedEntriesMap.set(keySubtype.priv.literalValue, {
                                             valueType: valueEntry.valueType,
                                             isReadOnly: valueEntry.isReadOnly,
                                             isRequired: false,
@@ -343,8 +359,8 @@ function narrowTypeBasedOnMappingPattern(evaluator, type, pattern, isPositiveTes
             }
             else if (mappingSubtypeInfo.dictTypeArgs) {
                 if (mappingEntry.nodeType === 71 /* ParseNodeType.PatternMappingKeyEntry */) {
-                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.keyPattern, isPositiveTest);
-                    const narrowedValueType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.valuePattern, isPositiveTest);
+                    const narrowedKeyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.d.keyPattern, isPositiveTest);
+                    const narrowedValueType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.d.valuePattern, isPositiveTest);
                     if ((0, types_1.isNever)(narrowedKeyType) || (0, types_1.isNever)(narrowedValueType)) {
                         isPlausibleMatch = false;
                     }
@@ -364,18 +380,18 @@ function getPositionalMatchArgNames(evaluator, type) {
         if ((0, types_1.isClassInstance)(matchArgsType) &&
             (0, typeUtils_1.isTupleClass)(matchArgsType) &&
             !(0, typeUtils_1.isUnboundedTupleClass)(matchArgsType) &&
-            matchArgsType.tupleTypeArguments) {
-            const tupleArgs = matchArgsType.tupleTypeArguments;
+            matchArgsType.priv.tupleTypeArguments) {
+            const tupleArgs = matchArgsType.priv.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 tupleArgs.map((arg) => arg.type.priv.literalValue);
             }
         }
     }
     return [];
 }
 function narrowTypeBasedOnLiteralPattern(evaluator, type, pattern, isPositiveTest) {
-    const literalType = evaluator.getTypeOfExpression(pattern.expression).type;
+    const literalType = evaluator.getTypeOfExpression(pattern.d.expr).type;
     if (!isPositiveTest) {
         return evaluator.mapSubtypesExpandTypeVars(type, 
         /* options */ undefined, (expandedSubtype, unexpandedSubtype) => {
@@ -392,11 +408,11 @@ function narrowTypeBasedOnLiteralPattern(evaluator, type, pattern, isPositiveTes
             // Narrow a non-literal bool based on a literal bool pattern.
             if ((0, types_1.isClassInstance)(expandedSubtype) &&
                 types_1.ClassType.isBuiltIn(expandedSubtype, 'bool') &&
-                expandedSubtype.literalValue === undefined &&
+                expandedSubtype.priv.literalValue === undefined &&
                 (0, types_1.isClassInstance)(literalType) &&
                 types_1.ClassType.isBuiltIn(literalType, 'bool') &&
-                literalType.literalValue !== undefined) {
-                return types_1.ClassType.cloneWithLiteral(literalType, !literalType.literalValue);
+                literalType.priv.literalValue !== undefined) {
+                return types_1.ClassType.cloneWithLiteral(literalType, !literalType.priv.literalValue);
             }
             return expandedSubtype;
         });
@@ -419,17 +435,18 @@ function narrowTypeBasedOnLiteralPattern(evaluator, type, pattern, isPositiveTes
     });
 }
 function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest) {
-    let exprType = evaluator.getTypeOfExpression(pattern.className, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+    var _a;
+    let exprType = evaluator.getTypeOfExpression(pattern.d.className, 2 /* EvalFlags.CallBaseDefaults */).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) {
+    if ((0, types_1.isClass)(exprType) && !((_a = exprType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
         exprType = types_1.ClassType.cloneRemoveTypePromotions(exprType);
-        exprType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(exprType);
+        exprType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(exprType, evaluator.getTupleClassType());
     }
     // 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) && (0, types_1.isInstantiableClass)(exprType)) {
+    if (pattern.d.args.some((arg) => !arg.d.name) && (0, types_1.isInstantiableClass)(exprType)) {
         positionalArgNames = getPositionalMatchArgNames(evaluator, exprType);
     }
     if (!isPositiveTest) {
@@ -438,7 +455,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
             return type;
         }
         let classType = exprType;
-        if (classType.details.typeParameters.length > 0) {
+        if (classType.shared.typeParameters.length > 0) {
             classType = types_1.ClassType.cloneForSpecialization(classType, 
             /* typeArguments */ undefined, 
             /* isTypeArgumentExplicit */ false);
@@ -452,7 +469,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
             // Handle the case where the class pattern references type() or a subtype thereof
             // and the subject type is an instantiable class itself.
             if (isPatternMetaclass && (0, types_1.isInstantiableClass)(subjectSubtypeExpanded)) {
-                const metaclass = (_a = subjectSubtypeExpanded.details.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                const metaclass = (_a = subjectSubtypeExpanded.shared.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 if ((0, types_1.isInstantiableClass)(classType) && evaluator.assignType(classType, metaclass)) {
                     return undefined;
                 }
@@ -478,7 +495,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
             if (!evaluator.assignType(classInstance, subjectSubtypeExpanded)) {
                 return subjectSubtypeExpanded;
             }
-            if (pattern.arguments.length === 0) {
+            if (pattern.d.args.length === 0) {
                 if ((0, types_1.isClass)(classInstance) && (0, types_1.isClass)(subjectSubtypeExpanded)) {
                     // We know that this match will always succeed, so we can
                     // eliminate this subtype.
@@ -497,8 +514,8 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                     return subjectSubtypeExpanded;
                 }
             }
-            for (let index = 0; index < pattern.arguments.length; index++) {
-                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, pattern.arguments[index], index, positionalArgNames, subjectSubtypeExpanded, isPositiveTest);
+            for (let index = 0; index < pattern.d.args.length; index++) {
+                const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, pattern.d.args[index], index, positionalArgNames, subjectSubtypeExpanded, isPositiveTest);
                 if (!(0, types_1.isNever)(narrowedArgType)) {
                     return subjectSubtypeUnexpanded;
                 }
@@ -508,13 +525,13 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
         });
     }
     if (!types_1.TypeBase.isInstantiable(exprType) && !(0, types_1.isNever)(exprType)) {
-        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.className);
+        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.d.className);
         return types_1.NeverType.createNever();
     }
     else if ((0, types_1.isInstantiableClass)(exprType) &&
         types_1.ClassType.isProtocolClass(exprType) &&
         !types_1.ClassType.isRuntimeCheckable(exprType)) {
-        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.protocolRequiresRuntimeCheckable(), pattern.className);
+        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.protocolRequiresRuntimeCheckable(), pattern.d.className);
     }
     return evaluator.mapSubtypesExpandTypeVars(exprType, 
     /* options */ undefined, (expandedSubtype, unexpandedSubtype) => {
@@ -532,7 +549,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                         const unknownCallable = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
                         types_1.FunctionType.addDefaultParameters(unknownCallable, 
                         /* useUnknown */ (0, types_1.isUnknown)(subjectSubtypeExpanded));
-                        unknownCallable.details.declaredReturnType = subjectSubtypeExpanded;
+                        unknownCallable.shared.declaredReturnType = subjectSubtypeExpanded;
                         return unknownCallable;
                     }
                     return (0, typeUtils_1.convertToInstance)(unexpandedSubtype);
@@ -540,7 +557,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                 // Handle the case where the class pattern references type() or a subtype thereof
                 // and the subject type is a class itself.
                 if (isPatternMetaclass && (0, types_1.isInstantiableClass)(subjectSubtypeExpanded)) {
-                    const metaclass = (_a = subjectSubtypeExpanded.details.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                    const metaclass = (_a = subjectSubtypeExpanded.shared.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                     if (evaluator.assignType(expandedSubtype, metaclass) ||
                         evaluator.assignType(metaclass, expandedSubtype)) {
                         return subjectSubtypeExpanded;
@@ -575,17 +592,18 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                         // 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) {
+                                unexpandedSubtype.shared.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, 
+                                if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, matchTypeInstance, subjectSubtypeExpanded, typeVarContext, 
                                 /* liveTypeVarScopes */ undefined, 
                                 /* usageOffset */ undefined)) {
                                     resultType = (0, typeUtils_1.applySolvedTypeVars)(matchTypeInstance, typeVarContext, {
                                         unknownIfNotFound: true,
+                                        tupleClassType: evaluator.getTupleClassType(),
                                     });
                                 }
                             }
@@ -597,11 +615,11 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
                     // 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 (pattern.d.args.some((arg) => !arg.d.name)) {
                         positionalArgNames = getPositionalMatchArgNames(evaluator, expandedSubtype);
                     }
                     let isMatchValid = true;
-                    pattern.arguments.forEach((arg, index) => {
+                    pattern.d.args.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.
@@ -623,7 +641,7 @@ function narrowTypeBasedOnClassPattern(evaluator, type, pattern, isPositiveTest)
 // Some built-in classes are treated as special cases for the class pattern
 // if a positional argument is used.
 function isClassSpecialCaseForClassPattern(classType) {
-    if (classPatternSpecialCases.some((className) => classType.details.fullName === className)) {
+    if (classPatternSpecialCases.some((className) => classType.shared.fullName === className)) {
         return true;
     }
     // If the class supplies its own `__match_args__`, it's not a special case.
@@ -632,9 +650,8 @@ function isClassSpecialCaseForClassPattern(classType) {
         return false;
     }
     // If the class derives from a built-in class, it is considered a special case.
-    for (const mroClass of classType.details.mro) {
-        if ((0, types_1.isClass)(mroClass) &&
-            classPatternSpecialCases.some((className) => mroClass.details.fullName === className)) {
+    for (const mroClass of classType.shared.mro) {
+        if ((0, types_1.isClass)(mroClass) && classPatternSpecialCases.some((className) => mroClass.shared.fullName === className)) {
             return true;
         }
     }
@@ -644,8 +661,8 @@ function isClassSpecialCaseForClassPattern(classType) {
 function narrowTypeOfClassPatternArgument(evaluator, arg, argIndex, positionalArgNames, matchType, isPositiveTest) {
     var _a;
     let argName;
-    if (arg.name) {
-        argName = arg.name.value;
+    if (arg.d.name) {
+        argName = arg.d.name.d.value;
     }
     else if (argIndex < positionalArgNames.length) {
         argName = positionalArgNames[argIndex];
@@ -662,12 +679,12 @@ function narrowTypeOfClassPatternArgument(evaluator, arg, argIndex, positionalAr
     // if the subclass doesn't define its own __match_args__.
     let useSelfForPattern = false;
     let selfForPatternType = matchType;
-    if (!arg.name && (0, types_1.isClass)(matchType) && argIndex === 0) {
+    if (!arg.d.name && (0, types_1.isClass)(matchType) && argIndex === 0) {
         if (isClassSpecialCaseForClassPattern(matchType)) {
             useSelfForPattern = true;
         }
         else if (positionalArgNames.length === 0) {
-            matchType.details.mro.forEach((mroClass) => {
+            matchType.shared.mro.forEach((mroClass) => {
                 if ((0, types_1.isClass)(mroClass) && isClassSpecialCaseForClassPattern(mroClass)) {
                     selfForPatternType = mroClass;
                     useSelfForPattern = true;
@@ -699,10 +716,10 @@ function narrowTypeOfClassPatternArgument(evaluator, arg, argIndex, positionalAr
             argType = types_1.UnknownType.create();
         }
     }
-    return narrowTypeBasedOnPattern(evaluator, argType, arg.pattern, isPositiveTest);
+    return narrowTypeBasedOnPattern(evaluator, argType, arg.d.pattern, isPositiveTest);
 }
 function narrowTypeBasedOnValuePattern(evaluator, subjectType, pattern, isPositiveTest) {
-    const valueType = evaluator.getTypeOfExpression(pattern.expression).type;
+    const valueType = evaluator.getTypeOfExpression(pattern.d.expr).type;
     const narrowedSubtypes = [];
     evaluator.mapSubtypesExpandTypeVars(valueType, 
     /* options */ undefined, (valueSubtypeExpanded, valueSubtypeUnexpanded) => {
@@ -748,7 +765,7 @@ function narrowTypeBasedOnValuePattern(evaluator, subjectType, pattern, isPositi
             }
             // Determine if assignment is supported for this combination of
             // value subtype and matching subtype.
-            const returnType = evaluator.useSpeculativeMode(pattern.expression, () => evaluator.getTypeOfMagicMethodCall(valueSubtypeExpanded, '__eq__', [{ type: subjectSubtypeExpanded }], pattern.expression, 
+            const returnType = evaluator.useSpeculativeMode(pattern.d.expr, () => evaluator.getTypeOfMagicMethodCall(valueSubtypeExpanded, '__eq__', [{ type: subjectSubtypeExpanded }], pattern.d.expr, 
             /* expectedType */ undefined));
             return returnType ? valueSubtypeUnexpanded : undefined;
         }));
@@ -765,6 +782,8 @@ function getMappingPatternInfo(evaluator, type, node) {
         if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
             mappingInfo.push({
                 subtype,
+                isDefinitelyMapping: false,
+                isDefinitelyNotMapping: false,
                 dictTypeArgs: {
                     key: concreteSubtype,
                     value: concreteSubtype,
@@ -777,13 +796,15 @@ function getMappingPatternInfo(evaluator, type, node) {
             if (types_1.ClassType.isTypedDictClass(concreteSubtype)) {
                 mappingInfo.push({
                     subtype,
+                    isDefinitelyMapping: true,
+                    isDefinitelyNotMapping: false,
                     typedDict: concreteSubtype,
                 });
                 return;
             }
             // Is it a subclass of Mapping?
             let mroClassToSpecialize;
-            for (const mroClass of concreteSubtype.details.mro) {
+            for (const mroClass of concreteSubtype.shared.mro) {
                 if ((0, types_1.isInstantiableClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'Mapping')) {
                     mroClassToSpecialize = mroClass;
                     break;
@@ -791,12 +812,14 @@ function getMappingPatternInfo(evaluator, type, node) {
             }
             if (mroClassToSpecialize) {
                 const specializedMapping = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype);
-                if (specializedMapping.typeArguments && specializedMapping.typeArguments.length >= 2) {
+                if (specializedMapping.priv.typeArguments && specializedMapping.priv.typeArguments.length >= 2) {
                     mappingInfo.push({
                         subtype,
+                        isDefinitelyMapping: true,
+                        isDefinitelyNotMapping: false,
                         dictTypeArgs: {
-                            key: specializedMapping.typeArguments[0],
-                            value: specializedMapping.typeArguments[1],
+                            key: specializedMapping.priv.typeArguments[0],
+                            value: specializedMapping.priv.typeArguments[1],
                         },
                     });
                 }
@@ -806,9 +829,11 @@ function getMappingPatternInfo(evaluator, type, node) {
             const mappingType = evaluator.getTypingType(node, 'Mapping');
             if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
                 const mappingObject = types_1.ClassType.cloneAsInstance(mappingType);
-                if (evaluator.assignType(type, mappingObject)) {
+                if (evaluator.assignType(subtype, mappingObject)) {
                     mappingInfo.push({
                         subtype,
+                        isDefinitelyMapping: false,
+                        isDefinitelyNotMapping: false,
                         dictTypeArgs: {
                             key: types_1.UnknownType.create(),
                             value: types_1.UnknownType.create(),
@@ -816,6 +841,11 @@ function getMappingPatternInfo(evaluator, type, node) {
                     });
                 }
             }
+            mappingInfo.push({
+                subtype,
+                isDefinitelyMapping: false,
+                isDefinitelyNotMapping: true,
+            });
         }
     });
     return mappingInfo;
@@ -824,8 +854,8 @@ function getMappingPatternInfo(evaluator, type, node) {
 // 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, pattern, type) {
-    const patternEntryCount = pattern.entries.length;
-    const patternStarEntryIndex = pattern.starEntryIndex;
+    const patternEntryCount = pattern.d.entries.length;
+    const patternStarEntryIndex = pattern.d.starEntryIndex;
     const sequenceInfo = [];
     (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
         var _a;
@@ -833,7 +863,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
         let mroClassToSpecialize;
         let pushedEntry = false;
         if ((0, types_1.isClassInstance)(concreteSubtype)) {
-            for (const mroClass of concreteSubtype.details.mro) {
+            for (const mroClass of concreteSubtype.shared.mro) {
                 if (!(0, types_1.isInstantiableClass)(mroClass)) {
                     break;
                 }
@@ -862,13 +892,15 @@ function getSequencePatternInfo(evaluator, pattern, type) {
             if (mroClassToSpecialize) {
                 const specializedSequence = (0, typeUtils_1.partiallySpecializeType)(mroClassToSpecialize, concreteSubtype);
                 if ((0, typeUtils_1.isTupleClass)(specializedSequence)) {
-                    const typeArgs = (_a = specializedSequence.tupleTypeArguments) !== null && _a !== void 0 ? _a : [
+                    const typeArgs = (_a = specializedSequence.priv.tupleTypeArguments) !== null && _a !== void 0 ? _a : [
                         { type: types_1.UnknownType.create(), isUnbounded: true },
                     ];
                     const tupleIndeterminateIndex = typeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
+                    let tupleDeterminateEntryCount = typeArgs.length;
                     // If the tuple contains an indeterminate entry, expand or remove that
                     // entry to match the length of the pattern if possible.
                     if (tupleIndeterminateIndex >= 0) {
+                        tupleDeterminateEntryCount--;
                         while (typeArgs.length < patternEntryCount) {
                             typeArgs.splice(tupleIndeterminateIndex, 0, typeArgs[tupleIndeterminateIndex]);
                         }
@@ -891,11 +923,17 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                     if (typeArgs.length === patternEntryCount) {
                         let isDefiniteNoMatch = false;
                         let isPotentialNoMatch = tupleIndeterminateIndex >= 0;
-                        if (patternStarEntryIndex !== undefined && patternEntryCount === 1) {
+                        // If the pattern includes a "star entry" and the tuple includes an
+                        // indeterminate-length entry that aligns to the star entry, we can
+                        // assume it will always match.
+                        if (patternStarEntryIndex !== undefined &&
+                            tupleIndeterminateIndex >= 0 &&
+                            pattern.d.entries.length - 1 === tupleDeterminateEntryCount &&
+                            patternStarEntryIndex === tupleIndeterminateIndex) {
                             isPotentialNoMatch = false;
                         }
                         for (let i = 0; i < patternEntryCount; i++) {
-                            const subPattern = pattern.entries[i];
+                            const subPattern = pattern.d.entries[i];
                             const typeArg = typeArgs[i].type;
                             const narrowedType = narrowTypeBasedOnPattern(evaluator, typeArg, subPattern, 
                             /* isPositiveTest */ true);
@@ -935,7 +973,7 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                                 if (i === patternStarEntryIndex) {
                                     continue;
                                 }
-                                const subPattern = pattern.entries[i];
+                                const subPattern = pattern.d.entries[i];
                                 const typeArg = typeArgs[i].type;
                                 const narrowedType = narrowTypeBasedOnPattern(evaluator, typeArg, subPattern, 
                                 /* isPositiveTest */ true);
@@ -958,8 +996,8 @@ function getSequencePatternInfo(evaluator, pattern, type) {
                     sequenceInfo.push({
                         subtype,
                         entryTypes: [
-                            specializedSequence.typeArguments && specializedSequence.typeArguments.length > 0
-                                ? specializedSequence.typeArguments[0]
+                            specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0
+                                ? specializedSequence.priv.typeArguments[0]
                                 : types_1.UnknownType.create(),
                         ],
                         isIndeterminateLength: true,
@@ -974,12 +1012,12 @@ function getSequencePatternInfo(evaluator, pattern, type) {
             const sequenceType = evaluator.getTypingType(pattern, 'Sequence');
             if (sequenceType && (0, types_1.isInstantiableClass)(sequenceType)) {
                 const sequenceTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(sequenceType));
-                if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(sequenceType), subtype, sequenceTypeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(pattern), pattern.start)) {
+                if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(sequenceType), subtype, sequenceTypeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(pattern), pattern.start)) {
                     const specializedSequence = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(sequenceType), sequenceTypeVarContext);
-                    if (specializedSequence.typeArguments && specializedSequence.typeArguments.length > 0) {
+                    if (specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0) {
                         sequenceInfo.push({
                             subtype,
-                            entryTypes: [specializedSequence.typeArguments[0]],
+                            entryTypes: [specializedSequence.priv.typeArguments[0]],
                             isIndeterminateLength: true,
                             isDefiniteNoMatch: false,
                             isPotentialNoMatch: true,
@@ -1026,7 +1064,16 @@ function getTypeOfPatternSequenceEntry(evaluator, node, sequenceInfo, entryIndex
         // Note that we strip literal types here.
         const starEntryTypes = sequenceInfo.entryTypes
             .slice(starEntryIndex, starEntryIndex + sequenceInfo.entryTypes.length - entryCount + 1)
-            .map((type) => evaluator.stripLiteralValue(type));
+            .map((type) => {
+            // If this is a variadic TypeVar, there's not much we can say about
+            // its type other than it's "Unknown". We could evaluate it as an
+            // "object", but that will cause problems given that this type will
+            // be wrapped in a "list" below, and lists are invariant.
+            if ((0, types_1.isVariadicTypeVar)(type) && !type.priv.isVariadicInUnion) {
+                return types_1.UnknownType.create();
+            }
+            return evaluator.stripLiteralValue(type);
+        });
         let entryType = (0, types_1.combineTypes)(starEntryTypes);
         if (!unpackStarEntry) {
             entryType = wrapTypeInList(evaluator, node, entryType);
@@ -1047,19 +1094,19 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
     switch (pattern.nodeType) {
         case 65 /* ParseNodeType.PatternSequence */: {
             const sequenceInfo = getSequencePatternInfo(evaluator, pattern, narrowedType).filter((seqInfo) => !seqInfo.isDefiniteNoMatch);
-            pattern.entries.forEach((entry, index) => {
-                const entryType = (0, types_1.combineTypes)(sequenceInfo.map((info) => getTypeOfPatternSequenceEntry(evaluator, pattern, info, index, pattern.entries.length, pattern.starEntryIndex, 
+            pattern.d.entries.forEach((entry, index) => {
+                const entryType = (0, types_1.combineTypes)(sequenceInfo.map((info) => getTypeOfPatternSequenceEntry(evaluator, pattern, info, index, pattern.d.entries.length, pattern.d.starEntryIndex, 
                 /* unpackStarEntry */ false)));
                 assignTypeToPatternTargets(evaluator, entryType, isTypeIncomplete, entry);
             });
             break;
         }
         case 66 /* ParseNodeType.PatternAs */: {
-            if (pattern.target) {
-                evaluator.assignTypeToExpression(pattern.target, { type: narrowedType, isIncomplete: isTypeIncomplete }, pattern.target);
+            if (pattern.d.target) {
+                evaluator.assignTypeToExpression(pattern.d.target, { type: narrowedType, isIncomplete: isTypeIncomplete }, pattern.d.target);
             }
             let runningNarrowedType = narrowedType;
-            pattern.orPatterns.forEach((orPattern) => {
+            pattern.d.orPatterns.forEach((orPattern) => {
                 assignTypeToPatternTargets(evaluator, runningNarrowedType, isTypeIncomplete, orPattern);
                 // OR patterns are evaluated left to right, so we can narrow
                 // the type as we go.
@@ -1069,10 +1116,10 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
             break;
         }
         case 69 /* ParseNodeType.PatternCapture */: {
-            if (pattern.isWildcard) {
+            if (pattern.d.isWildcard) {
                 if (!isTypeIncomplete) {
                     if ((0, types_1.isUnknown)(narrowedType)) {
-                        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.wildcardPatternTypeUnknown(), pattern.target);
+                        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.wildcardPatternTypeUnknown(), pattern.d.target);
                     }
                     else if ((0, typeUtils_1.isPartlyUnknown)(narrowedType)) {
                         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -1080,24 +1127,24 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                             name: '_',
                             type: evaluator.printType(narrowedType, { expandTypeAlias: true }),
                         }));
-                        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.wildcardPatternTypePartiallyUnknown() + diagAddendum.getString(), pattern.target);
+                        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.wildcardPatternTypePartiallyUnknown() + diagAddendum.getString(), pattern.d.target);
                     }
                 }
             }
             else {
-                evaluator.assignTypeToExpression(pattern.target, { type: narrowedType, isIncomplete: isTypeIncomplete }, pattern.target);
+                evaluator.assignTypeToExpression(pattern.d.target, { type: narrowedType, isIncomplete: isTypeIncomplete }, pattern.d.target);
             }
             break;
         }
         case 70 /* ParseNodeType.PatternMapping */: {
             const mappingInfo = getMappingPatternInfo(evaluator, narrowedType, pattern);
-            pattern.entries.forEach((mappingEntry) => {
+            pattern.d.entries.forEach((mappingEntry) => {
                 const keyTypes = [];
                 const valueTypes = [];
                 mappingInfo.forEach((mappingSubtypeInfo) => {
                     if (mappingSubtypeInfo.typedDict) {
                         if (mappingEntry.nodeType === 71 /* ParseNodeType.PatternMappingKeyEntry */) {
-                            const keyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.keyPattern, 
+                            const keyType = narrowTypeBasedOnPattern(evaluator, evaluator.getBuiltInObject(pattern, 'str'), mappingEntry.d.keyPattern, 
                             /* isPositiveTest */ true);
                             keyTypes.push(keyType);
                             (0, typeUtils_1.doForEachSubtype)(keyType, (keySubtype) => {
@@ -1105,7 +1152,7 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                                     types_1.ClassType.isBuiltIn(keySubtype, 'str') &&
                                     (0, typeUtils_1.isLiteralType)(keySubtype)) {
                                     const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, mappingSubtypeInfo.typedDict);
-                                    const valueInfo = tdEntries.knownItems.get(keySubtype.literalValue);
+                                    const valueInfo = tdEntries.knownItems.get(keySubtype.priv.literalValue);
                                     valueTypes.push(valueInfo ? valueInfo.valueType : types_1.UnknownType.create());
                                 }
                                 else {
@@ -1115,15 +1162,15 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                         }
                         else if (mappingEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
                             keyTypes.push(evaluator.getBuiltInObject(pattern, 'str'));
-                            valueTypes.push(types_1.UnknownType.create());
+                            valueTypes.push(evaluator.getObjectType());
                         }
                     }
                     else if (mappingSubtypeInfo.dictTypeArgs) {
                         if (mappingEntry.nodeType === 71 /* ParseNodeType.PatternMappingKeyEntry */) {
-                            const keyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.keyPattern, 
+                            const keyType = narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.key, mappingEntry.d.keyPattern, 
                             /* isPositiveTest */ true);
                             keyTypes.push(keyType);
-                            valueTypes.push(narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.valuePattern, 
+                            valueTypes.push(narrowTypeBasedOnPattern(evaluator, mappingSubtypeInfo.dictTypeArgs.value, mappingEntry.d.valuePattern, 
                             /* isPositiveTest */ true));
                         }
                         else if (mappingEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
@@ -1135,8 +1182,8 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                 const keyType = (0, types_1.combineTypes)(keyTypes);
                 const valueType = (0, types_1.combineTypes)(valueTypes);
                 if (mappingEntry.nodeType === 71 /* ParseNodeType.PatternMappingKeyEntry */) {
-                    assignTypeToPatternTargets(evaluator, keyType, isTypeIncomplete, mappingEntry.keyPattern);
-                    assignTypeToPatternTargets(evaluator, valueType, isTypeIncomplete, mappingEntry.valuePattern);
+                    assignTypeToPatternTargets(evaluator, keyType, isTypeIncomplete, mappingEntry.d.keyPattern);
+                    assignTypeToPatternTargets(evaluator, valueType, isTypeIncomplete, mappingEntry.d.valuePattern);
                 }
                 else if (mappingEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
                     const dictClass = evaluator.getBuiltInType(pattern, 'dict');
@@ -1145,19 +1192,19 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                         ? types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictClass, [keyType, valueType], 
                         /* isTypeArgumentExplicit */ true))
                         : types_1.UnknownType.create();
-                    evaluator.assignTypeToExpression(mappingEntry.target, { type: dictType, isIncomplete: isTypeIncomplete }, mappingEntry.target);
+                    evaluator.assignTypeToExpression(mappingEntry.d.target, { type: dictType, isIncomplete: isTypeIncomplete }, mappingEntry.d.target);
                 }
             });
             break;
         }
         case 68 /* ParseNodeType.PatternClass */: {
-            const argTypes = pattern.arguments.map((arg) => []);
+            const argTypes = pattern.d.args.map((arg) => []);
             evaluator.mapSubtypesExpandTypeVars(narrowedType, /* options */ undefined, (expandedSubtype) => {
                 if ((0, types_1.isClassInstance)(expandedSubtype)) {
                     (0, typeUtils_1.doForEachSubtype)(narrowedType, (subjectSubtype) => {
                         const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subjectSubtype);
                         if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
-                            pattern.arguments.forEach((arg, index) => {
+                            pattern.d.args.forEach((arg, index) => {
                                 argTypes[index].push(concreteSubtype);
                             });
                         }
@@ -1165,10 +1212,10 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                             // 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 (pattern.d.args.some((arg) => !arg.d.name)) {
                                 positionalArgNames = getPositionalMatchArgNames(evaluator, types_1.ClassType.cloneAsInstantiable(expandedSubtype));
                             }
-                            pattern.arguments.forEach((arg, index) => {
+                            pattern.d.args.forEach((arg, index) => {
                                 const narrowedArgType = narrowTypeOfClassPatternArgument(evaluator, arg, index, positionalArgNames, types_1.ClassType.cloneAsInstantiable(expandedSubtype), 
                                 /* isPositiveTest */ true);
                                 argTypes[index].push(narrowedArgType);
@@ -1177,14 +1224,14 @@ function assignTypeToPatternTargets(evaluator, type, isTypeIncomplete, pattern)
                     });
                 }
                 else {
-                    pattern.arguments.forEach((arg, index) => {
+                    pattern.d.args.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, arg.pattern);
+            pattern.d.args.forEach((arg, index) => {
+                assignTypeToPatternTargets(evaluator, (0, types_1.combineTypes)(argTypes[index]), isTypeIncomplete, arg.d.pattern);
             });
             break;
         }
@@ -1213,55 +1260,56 @@ function wrapTypeInList(evaluator, node, type) {
     return types_1.UnknownType.create();
 }
 function validateClassPattern(evaluator, pattern) {
-    let exprType = evaluator.getTypeOfExpression(pattern.className, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+    var _a, _b;
+    let exprType = evaluator.getTypeOfExpression(pattern.d.className, 2 /* EvalFlags.CallBaseDefaults */).type;
     // If the expression is a type alias or other special form, treat it
     // as the special form rather than the class.
-    if (exprType.specialForm) {
-        exprType = exprType.specialForm;
+    if ((_a = exprType.props) === null || _a === void 0 ? void 0 : _a.specialForm) {
+        exprType = exprType.props.specialForm;
     }
     if ((0, types_1.isAnyOrUnknown)(exprType)) {
         return;
     }
     // Check for certain uses of type aliases that generate runtime exceptions.
-    if (exprType.typeAliasInfo &&
+    if (((_b = exprType.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) &&
         (0, types_1.isInstantiableClass)(exprType) &&
-        exprType.typeArguments &&
-        exprType.isTypeArgumentExplicit) {
-        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternTypeAlias().format({ type: evaluator.printType(exprType) }), pattern.className);
+        exprType.priv.typeArguments &&
+        exprType.priv.isTypeArgumentExplicit) {
+        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternTypeAlias().format({ type: evaluator.printType(exprType) }), pattern.d.className);
     }
     else if (!(0, types_1.isInstantiableClass)(exprType)) {
         if (!(0, types_1.isNever)(exprType)) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.className);
+            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocAddendum.typeNotClass().format({ type: evaluator.printType(exprType) }), pattern.d.className);
         }
     }
     else {
         const isBuiltIn = isClassSpecialCaseForClassPattern(exprType);
         // If it's a special-case builtin class, only positional arguments are allowed.
         if (isBuiltIn) {
-            if (pattern.arguments.length === 1 && pattern.arguments[0].name) {
-                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternBuiltInArgPositional(), pattern.arguments[0].name);
+            if (pattern.d.args.length === 1 && pattern.d.args[0].d.name) {
+                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternBuiltInArgPositional(), pattern.d.args[0].d.name);
             }
         }
         // Emits an error if the supplied number of positional patterns is less than
         // expected for the given subject type.
-        let positionalPatternCount = pattern.arguments.findIndex((arg) => arg.name !== undefined);
+        let positionalPatternCount = pattern.d.args.findIndex((arg) => arg.d.name !== undefined);
         if (positionalPatternCount < 0) {
-            positionalPatternCount = pattern.arguments.length;
+            positionalPatternCount = pattern.d.args.length;
         }
         let expectedPatternCount = 1;
         if (!isBuiltIn) {
             let positionalArgNames = [];
-            if (pattern.arguments.some((arg) => !arg.name)) {
+            if (pattern.d.args.some((arg) => !arg.d.name)) {
                 positionalArgNames = getPositionalMatchArgNames(evaluator, exprType);
             }
             expectedPatternCount = positionalArgNames.length;
         }
         if (positionalPatternCount > expectedPatternCount) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classPatternPositionalArgCount().format({
-                type: exprType.details.name,
+                type: exprType.shared.name,
                 expected: expectedPatternCount,
                 received: positionalPatternCount,
-            }), pattern.arguments[expectedPatternCount]);
+            }), pattern.d.args[expectedPatternCount]);
         }
     }
 }
@@ -1274,22 +1322,22 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
     // <literal> is either a str (for TypedDict discrimination) or an int
     // (for tuple discrimination).
     if (subjectExpression.nodeType === 27 /* ParseNodeType.Index */ &&
-        subjectExpression.items.length === 1 &&
-        !subjectExpression.trailingComma &&
-        subjectExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-        (0, parseTreeUtils_1.isMatchingExpression)(reference, subjectExpression.baseExpression)) {
-        const indexTypeResult = evaluator.getTypeOfExpression(subjectExpression.items[0].valueExpression);
+        subjectExpression.d.items.length === 1 &&
+        !subjectExpression.d.trailingComma &&
+        subjectExpression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+        (0, parseTreeUtils_1.isMatchingExpression)(reference, subjectExpression.d.leftExpr)) {
+        const indexTypeResult = evaluator.getTypeOfExpression(subjectExpression.d.items[0].d.valueExpr);
         const indexType = indexTypeResult.type;
         if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
             if (types_1.ClassType.isBuiltIn(indexType, ['int', 'str'])) {
-                const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(subjectExpression.baseExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(subjectExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const unnarrowedReferenceType = unnarrowedReferenceTypeResult.type;
                 return (narrowedSubjectType) => {
                     let canNarrow = true;
                     const typesToCombine = [];
                     (0, typeUtils_1.doForEachSubtype)(narrowedSubjectType, (subtype) => {
                         subtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                        if ((0, types_1.isClassInstance)(subtype) && subtype.literalValue !== undefined) {
+                        if ((0, types_1.isClassInstance)(subtype) && subtype.priv.literalValue !== undefined) {
                             if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
                                 typesToCombine.push((0, typeGuards_1.narrowTypeForDiscriminatedDictEntryComparison)(evaluator, unnarrowedReferenceType, indexType, subtype, 
                                 /* isPositiveTest */ true));
@@ -1318,19 +1366,19 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
     // Look for a subject expression that contains the reference
     // expression as an entry in a tuple.
     if (subjectExpression.nodeType === 52 /* ParseNodeType.Tuple */) {
-        const matchingEntryIndex = subjectExpression.expressions.findIndex((expr) => (0, parseTreeUtils_1.isMatchingExpression)(reference, expr));
+        const matchingEntryIndex = subjectExpression.d.items.findIndex((expr) => (0, parseTreeUtils_1.isMatchingExpression)(reference, expr));
         if (matchingEntryIndex >= 0) {
-            const typeResult = evaluator.getTypeOfExpression(subjectExpression.expressions[matchingEntryIndex]);
+            const typeResult = evaluator.getTypeOfExpression(subjectExpression.d.items[matchingEntryIndex]);
             return (narrowedSubjectType) => {
                 let canNarrow = true;
                 const narrowedSubtypes = [];
                 (0, typeUtils_1.doForEachSubtype)(narrowedSubjectType, (subtype) => {
                     if ((0, types_1.isClassInstance)(subtype) &&
                         types_1.ClassType.isBuiltIn(subtype, 'tuple') &&
-                        subtype.tupleTypeArguments &&
-                        matchingEntryIndex < subtype.tupleTypeArguments.length &&
-                        subtype.tupleTypeArguments.every((e) => !e.isUnbounded)) {
-                        narrowedSubtypes.push(subtype.tupleTypeArguments[matchingEntryIndex].type);
+                        subtype.priv.tupleTypeArguments &&
+                        matchingEntryIndex < subtype.priv.tupleTypeArguments.length &&
+                        subtype.priv.tupleTypeArguments.every((e) => !e.isUnbounded)) {
+                        narrowedSubtypes.push(subtype.priv.tupleTypeArguments[matchingEntryIndex].type);
                     }
                     else if ((0, types_1.isNever)(narrowedSubjectType)) {
                         narrowedSubtypes.push(narrowedSubjectType);
@@ -1348,8 +1396,8 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
     // Look for a subject expression of the form "a.b" where "b" is an attribute
     // that is annotated with a literal type.
     if (subjectExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-        (0, parseTreeUtils_1.isMatchingExpression)(reference, subjectExpression.leftExpression)) {
-        const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(subjectExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+        (0, parseTreeUtils_1.isMatchingExpression)(reference, subjectExpression.d.leftExpr)) {
+        const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(subjectExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
         const unnarrowedReferenceType = unnarrowedReferenceTypeResult.type;
         return (narrowedSubjectType) => {
             if ((0, types_1.isNever)(narrowedSubjectType)) {
@@ -1359,8 +1407,8 @@ function getPatternSubtypeNarrowingCallback(evaluator, reference, subjectExpress
                 return undefined;
             }
             const resultType = (0, typeUtils_1.mapSubtypes)(narrowedSubjectType, (literalSubtype) => {
-                (0, debug_1.assert)((0, types_1.isClassInstance)(literalSubtype) && literalSubtype.literalValue !== undefined);
-                return (0, typeGuards_1.narrowTypeForDiscriminatedLiteralFieldComparison)(evaluator, unnarrowedReferenceType, subjectExpression.memberName.value, literalSubtype, 
+                (0, debug_1.assert)((0, types_1.isClassInstance)(literalSubtype) && literalSubtype.priv.literalValue !== undefined);
+                return (0, typeGuards_1.narrowTypeForDiscriminatedLiteralFieldComparison)(evaluator, unnarrowedReferenceType, subjectExpression.d.member.d.value, literalSubtype, 
                 /* isPositiveTest */ true);
             });
             return {