@zzzen/pyright-internal 1.2.0-dev.20230806 → 1.2.0-dev.20230820

package/dist/analyzer/typeEvaluator.js

@@ -157,7 +157,7 @@ const maxRecursiveTypeAliasRecursionCount = 10;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
-const verifyTypeCacheEvaluatorFlags = false;
+const verifyTypeCacheEvaluatorFlags = true;
 // This debugging option prints each expression and its evaluated type.
 const printExpressionTypes = false;
 // The following number is chosen somewhat arbitrarily. We need to cut
@@ -683,6 +683,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    function reportInvalidUseOfPep695TypeAlias(type, node) {
+        var _a;
+        // PEP 695 type aliases cannot be used as instantiable classes.
+        if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax && types_1.TypeBase.isSpecialForm(type)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasNotAllowed().format({ name: type.typeAliasInfo.name }), node);
+            return true;
+        }
+        return false;
+    }
     function validateTypeIsInstantiable(typeResult, flags, node) {
         var _a;
         // If the type is incomplete, don't log any diagnostics yet.
@@ -971,9 +980,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.associateTypeVarsWithScope) {
             evaluatorFlags |= 8192 /* AssociateTypeVarsWithCurrentScope */;
         }
-        else {
-            evaluatorFlags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
-        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
             evaluatorFlags |= 8388608 /* AllowUnpackedTypedDict */;
         }
@@ -1451,7 +1457,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* DoNotSpecialize */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 16777218 /* MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 16 /* DeclaredTypesOnly */);
@@ -1475,7 +1481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 24 /* Index */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* DoNotSpecialize */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* IndexBaseDefaults */).type);
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
                     const setItemMember = (0, typeUtils_1.lookUpClassMember)(baseType, '__setitem__');
                     if (setItemMember) {
@@ -2036,7 +2042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, 16777218 /* MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.leftExpression.nodeType === 38 /* Name */) {
@@ -2493,19 +2499,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is the source expression a TypeVar() call?
         if ((0, types_1.isTypeVar)(type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* Call */) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, 16777218 /* CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
                         types_1.ClassType.isBuiltIn(callType, 'ParamSpec'))) {
-                    if (target.nodeType !== 38 /* Name */ || target.value !== type.details.name) {
+                    const typeVarTarget = target.nodeType === 54 /* TypeAnnotation */ ? target.valueExpression : target;
+                    if (typeVarTarget.nodeType !== 38 /* Name */ || typeVarTarget.value !== type.details.name) {
                         addError(type.details.isParamSpec
                             ? localize_1.Localizer.Diagnostic.paramSpecAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
                             })
                             : localize_1.Localizer.Diagnostic.typeVarAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(type),
-                            }), target);
+                            }), typeVarTarget);
                     }
                 }
             }
@@ -2524,7 +2531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 24 /* Index */: {
-                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(target, baseTypeResult, {
                     method: 'set',
                     setType: { type, isIncomplete: isTypeIncomplete },
@@ -2561,8 +2568,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                assignTypeToExpression(target.valueExpression, type, 
-                /* isIncomplete */ false, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
+                assignTypeToExpression(target.valueExpression, type, isTypeIncomplete, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
             case 56 /* Unpack */: {
@@ -2652,14 +2658,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* MemberAccessBaseDefaults */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
                 writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
                 writeTypeCache(node, { type: memberType.type }, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
-                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
                 writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* None */);
                 break;
@@ -2914,6 +2920,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if ((flags & 16777216 /* DisallowPep695TypeAlias */) !== 0) {
+            if (reportInvalidUseOfPep695TypeAlias(type, node)) {
+                type = types_1.UnknownType.create();
+            }
+        }
         if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
@@ -3066,7 +3077,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else if ((flags & 4096 /* DisallowTypeVarsWithoutScopeId */) !== 0) {
+            else if ((flags & 4096 /* AllowTypeVarsWithoutScopeId */) === 0) {
                 if ((type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized) {
                     let message;
@@ -3143,7 +3154,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     name: type.typeAliasInfo.name,
                 }), node);
             }
-            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, defaultTypeArgs);
+            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
         }
         return type;
     }
@@ -3251,14 +3262,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
-        const baseTypeFlags = 2 /* DoNotSpecialize */ |
+        const baseTypeFlags = 16777218 /* MemberAccessBaseDefaults */ |
             (flags &
                 (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
                     2048 /* DisallowTypeVarsWithScopeId */ |
-                    4096 /* DisallowTypeVarsWithoutScopeId */ |
                     8192 /* AssociateTypeVarsWithCurrentScope */));
         const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
@@ -3875,10 +3885,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             },
                         ];
                         if (usage.method === 'get') {
-                            // Provide "objtype" argument.
+                            // Provide "owner" argument.
+                            // Use Any rather than None for the owner argument if accessing through an object.
+                            // None is more correct, but it doesn't really matter, and many descriptor classes
+                            // incorrectly annotate the owner parameter. Rather than create a bunch of noise,
+                            // we'll use Any here.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                typeResult: { type: baseTypeClass },
+                                typeResult: {
+                                    type: isAccessedThroughObject ? types_1.AnyType.create() : baseTypeClass,
+                                },
                             });
                         }
                         else if (usage.method === 'set') {
@@ -4233,7 +4249,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfIndex(node, flags = 0 /* None */) {
-        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* DoNotSpecialize */);
+        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* IndexBaseDefaults */);
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this will generate a runtime exception in Python versions
         // less than 3.10.
@@ -4474,6 +4490,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
+                                else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                    types_1.FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                }
                             }
                             else {
                                 types_1.FunctionType.addParameter(functionType, {
@@ -4545,7 +4565,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             aliasTypeArgs.push(typeVarType || types_1.UnknownType.create());
         });
-        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
+        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.isPep695Syntax, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
         return { type, node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
@@ -4556,7 +4576,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
@@ -4853,14 +4873,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeof valueType.literalValue === 'number') {
                 const indexValue = valueType.literalValue;
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
-                if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
-                    if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
-                        return { type: tupleType.tupleTypeArguments[indexValue].type };
-                    }
-                    else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
-                        return {
-                            type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue].type,
-                        };
+                if (tupleType && tupleType.tupleTypeArguments) {
+                    if ((0, typeUtils_1.isTupleIndexUnambiguous)(tupleType, indexValue)) {
+                        if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
+                            return { type: tupleType.tupleTypeArguments[indexValue].type };
+                        }
+                        else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
+                            return {
+                                type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue]
+                                    .type,
+                            };
+                        }
                     }
                 }
             }
@@ -5340,7 +5363,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */ | (flags & 4 /* AllowForwardReferences */));
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */ | (flags & 4 /* AllowForwardReferences */));
         }
         const argList = node.arguments.map((arg) => {
             const functionArg = {
@@ -5475,7 +5498,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         function getLambdaType() {
-            return getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+            return getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
         }
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
@@ -5485,7 +5508,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+            typeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */);
         }
         return typeResult;
     }
@@ -5650,7 +5673,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if ((0, types_1.isInstantiableClass)(secondArgType)) {
                 if ((0, types_1.isInstantiableClass)(targetClassType)) {
-                    if (!(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, targetClassType, /* ignoreUnknown */ true)) {
+                    if (!types_1.ClassType.isBuiltIn(targetClassType, 'type') &&
+                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, targetClassType, /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
                 }
@@ -6281,23 +6305,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        let effectiveTypeVarContext = typeVarContext;
+        if (!effectiveTypeVarContext) {
+            // If a typeVarContext wasn't provided by the caller, allocate one here.
+            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedCallType));
+        }
         // The stdlib collections/__init__.pyi stub file defines namedtuple
         // as a function rather than a class, so we need to check for it here.
         if (expandedCallType.details.builtInName === 'namedtuple') {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUntypedNamedTuple, diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.Localizer.Diagnostic.namedTupleNoTypes(), errorNode);
-            return {
+            const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
+            validateFunctionArguments(errorNode, argList, { type: expandedCallType }, effectiveTypeVarContext, skipUnknownArgCheck);
+            return result;
         }
         // Handle the NewType specially, replacing the normal return type.
         if (expandedCallType.details.builtInName === 'NewType') {
             return { returnType: createNewType(errorNode, argList) };
         }
-        let effectiveTypeVarContext = typeVarContext;
-        if (!effectiveTypeVarContext) {
-            // If a typeVarContext wasn't provided by the caller, allocate one here.
-            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedCallType));
-        }
         const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         let isTypeIncomplete = !!functionResult.isTypeIncomplete;
         let returnType = functionResult.returnType;
@@ -6424,9 +6450,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (className === 'NamedTuple') {
-                return {
+                const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
+                const initTypeResult = getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), '__init__');
+                if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
+                    validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
+                    /* typeVarContext */ undefined, skipUnknownArgCheck, 
+                    /* inferenceContext */ undefined);
+                }
+                return result;
             }
             if (className === 'NewType') {
                 return { returnType: createNewType(errorNode, argList) };
@@ -8072,7 +8105,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* AllowMissingTypeArgs */ |
                         8 /* EvaluateStringLiteralAsType */ |
                         32 /* DisallowParamSpec */ |
-                        64 /* DisallowTypeVarTuple */
+                        64 /* DisallowTypeVarTuple */ |
+                        16777216 /* DisallowPep695TypeAlias */
                     : 2 /* DoNotSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
@@ -8623,7 +8657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = [];
             let isTypeParamListValid = true;
             typeParamsExpr.expressions.map((expr) => {
-                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */).type;
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */ | 4096 /* AllowTypeVarsWithoutScopeId */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
                     if (entryType.scopeId) {
                         isTypeParamListValid = false;
@@ -8643,6 +8677,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
+        /* isPep695Syntax */ false, 
         /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
     }
     function getBooleanValue(node) {
@@ -8922,7 +8957,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfDictionaryWithContext(node, inferenceContext, expectedDiagAddendum) {
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
-        const concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
+        let concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
         if (!(0, types_1.isClassInstance)(concreteExpectedType)) {
             return undefined;
         }
@@ -8931,6 +8966,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Handle TypedDict's as a special case.
         if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
+            // Remove any conditions associated with the type so the resulting type isn't
+            // considered compatible with a bound TypeVar.
+            concreteExpectedType = types_1.TypeBase.cloneForCondition(concreteExpectedType, undefined);
             const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
             // Infer the key and value types if possible.
             if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
@@ -8940,17 +8978,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum)) {
                 isIncomplete = true;
             }
-            if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
-                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
-                // Don't overwrite existing expectedDiagAddendum messages if they were
-                // already provided by getKeyValueTypesFromDictionary.
-                (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
-                if (resultTypedDict) {
-                    return {
-                        type: resultTypedDict,
-                        isIncomplete,
-                    };
-                }
+            const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
+            // Don't overwrite existing expectedDiagAddendum messages if they were
+            // already provided by getKeyValueTypesFromDictionary.
+            (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
+            if (resultTypedDict) {
+                return {
+                    type: resultTypedDict,
+                    isIncomplete,
+                };
             }
             return undefined;
         }
@@ -9886,6 +9922,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
+                                else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                    types_1.FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                }
                             }
                             else {
                                 types_1.FunctionType.addParameter(functionType, {
@@ -10264,7 +10304,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             typeArgs.forEach((typeArg, index) => {
                 if (index === typeArgs.length - 1) {
-                    if (!(0, types_1.isParamSpec)(typeArg.type)) {
+                    if (!(0, types_1.isParamSpec)(typeArg.type) && !(0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         addError(localize_1.Localizer.Diagnostic.concatenateParamSpecMissing(), typeArg.node);
                     }
                 }
@@ -10322,7 +10362,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeArgs.forEach((typeArg, index) => {
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
-                            addError(localize_1.Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            if (!allowParamSpec) {
+                                addError(localize_1.Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            }
                         }
                         else if (typeArgs.length !== 2 || index !== 1) {
                             addError(localize_1.Localizer.Diagnostic.ellipsisSecondArg(), typeArg.node);
@@ -10490,7 +10532,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, typeParameters, typeParamNodes) {
+    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, typeParameters, typeParamNodes) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -10540,7 +10582,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
             }), errorNode);
         }
-        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
+        const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        // All PEP 695 type aliases are special forms because they are
+        // TypeAliasType objects at runtime.
+        if (isPep695Syntax) {
+            typeAlias.flags |= 8 /* SpecialForm */;
+        }
+        return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -10686,7 +10734,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function evaluateTypesForAssignmentStatement(node) {
-        var _a;
+        var _a, _b;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
@@ -10761,6 +10809,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
                     const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+                    typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = false;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
                     writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
@@ -10784,20 +10833,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         srcType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
                     }
                 }
-                // If there was a declared type, make sure the RHS value is compatible.
-                if (declaredType) {
-                    if (assignType(declaredType, srcType)) {
-                        // Narrow the resulting type if possible.
-                        if (!(0, types_1.isAnyOrUnknown)(srcType)) {
-                            srcType = narrowTypeBasedOnAssignment(node, declaredType, srcType);
-                        }
-                    }
-                }
                 // If this is an enum, transform the type as required.
                 rightHandType = srcType;
                 if (node.leftExpression.nodeType === 38 /* Name */ && !node.typeAnnotationComment) {
                     rightHandType =
-                        (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType) || rightHandType;
+                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType)) !== null && _a !== void 0 ? _a : rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
@@ -10805,7 +10845,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isSpeculativeTypeAlias ||
                         (types_1.TypeBase.isInstantiable(rightHandType) && !(0, types_1.isUnknown)(rightHandType))) {
                         // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression);
+                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
+                        /* isPep695Syntax */ false);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                                 name: typeAliasNameNode.value,
@@ -10817,7 +10858,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         typeAliasTypeVar.details.boundType = rightHandType;
                         // Record the type parameters within the recursive type alias so it
                         // can be specialized.
-                        typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
+                        typeAliasTypeVar.details.recursiveTypeParameters = (_b = rightHandType.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeParameters;
                     }
                 }
             }
@@ -10846,7 +10887,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     callLeftNode.leftExpression.nodeType === 38 /* Name */)) {
                 // See if this is a call to TypedDict. We want to support
                 // recursive type references in a TypedDict call.
-                const callType = getTypeOfExpression(callLeftNode, 2 /* DoNotSpecialize */).type;
+                const callType = getTypeOfExpression(callLeftNode, 16777218 /* CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
                     return true;
                 }
@@ -10859,7 +10900,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // variables since they use normal variable assignment syntax.
     function getTypeOfTypeAlias(node) {
         var _a;
-        return getTypeOfTypeAliasCommon(node, node.name, node.expression, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
+        return getTypeOfTypeAliasCommon(node, node.name, node.expression, 
+        /* isPep695Syntax */ true, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
             let typeParameters = [];
             if (node.typeParameters) {
                 typeParameters = evaluateTypeParameterList(node.typeParameters);
@@ -10869,7 +10911,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // This function is common to the handling of "type" statements and explicit
     // calls to the TypeAliasType constructor.
-    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, typeParamNodes, getTypeParamCallback) {
+    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, isPep695Syntax, typeParamNodes, getTypeParamCallback) {
         const cachedType = readTypeCache(nameNode, 0 /* None */);
         if (cachedType) {
             return cachedType;
@@ -10881,6 +10923,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeAliasTypeVar.details.recursiveTypeAliasName = nameNode.value;
         const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+        typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = isPep695Syntax;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
         writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
@@ -10902,7 +10945,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, typeParameters, typeParamNodes);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                 name: nameNode.value,
@@ -10998,7 +11041,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
             8192 /* AssociateTypeVarsWithCurrentScope */ |
-            16384 /* EnforceTypeVarVarianceConsistency */;
+            16384 /* EnforceTypeVarVarianceConsistency */ |
+            16777216 /* DisallowPep695TypeAlias */;
         if (fileInfo.isStubFile) {
             exprFlags |= 4 /* AllowForwardReferences */;
         }
@@ -11249,6 +11293,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         classType.details.fields = (innerScope === null || innerScope === void 0 ? void 0 : innerScope.symbolTable)
             ? new Map(innerScope.symbolTable)
             : new Map();
+        // Determine whether the class should inherit __hash__. If a class defines
+        // __eq__ but doesn't define __hash__ then __hash__ is set to None.
+        if (classType.details.fields.has('__eq__') && !classType.details.fields.has('__hash__')) {
+            classType.details.fields.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 128 /* ClassVar */ | 64 /* IgnoredForProtocolMatch */, types_1.NoneType.createInstance()));
+        }
         // Determine whether the class's instance variables are constrained
         // to those defined by __slots__. We need to do this prior to dataclass
         // processing because dataclasses can implicitly add to the slots
@@ -11299,7 +11348,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 classType.details.flags |= 262144 /* HasCustomClassGetItem */;
             }
         }
-        // Determine the effective metaclass and detect metaclass conflicts.
+        // Determine the effective metaclass.
         if (metaclassNode) {
             const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
             if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
@@ -12085,11 +12134,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             validateTypeParameterDefault(bestErrorNode, typeParam, functionType.details.typeParameters.slice(0, index));
         });
+        // If it's an async function, wrap the return type in an Awaitable or Generator.
+        const preDecoratedType = node.isAsync ? createAsyncFunction(node, functionType) : functionType;
         // Clear the "partially evaluated" flag to indicate that the functionType
         // is fully evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        // If it's an async function, wrap the return type in an Awaitable or Generator.
-        const preDecoratedType = node.isAsync ? createAsyncFunction(node, functionType) : functionType;
         // Apply all of the decorators in reverse order.
         let decoratedType = preDecoratedType;
         let foundUnknown = false;
@@ -12302,7 +12351,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, debug_1.assert)(types_1.FunctionType.isAsync(functionType));
         // Clone the original function and replace its return type with an
         // Awaitable[<returnType>]. Mark the new function as no longer async.
-        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~512 /* Async */);
+        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~(512 /* Async */ | 131072 /* PartiallyEvaluated */));
         if (functionType.details.declaredReturnType) {
             awaitableFunctionType.details.declaredReturnType = createAwaitableReturnType(node, functionType.details.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
@@ -12785,7 +12834,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (const caseStatement of node.parent.cases) {
             if (caseStatement === node) {
                 if (fileInfo.diagnosticRuleSet.reportUnnecessaryComparison !== 'none') {
-                    (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.pattern, subjectType);
+                    if (!subjectTypeResult.isIncomplete) {
+                        (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.pattern, subjectType);
+                    }
                 }
                 break;
             }
@@ -12801,23 +12852,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isTypeCached(node)) {
             return;
         }
-        // Use the first element of the name parts as the symbol.
-        const symbolNameNode = node.module.nameParts[0];
-        // Look up the symbol to find the alias declaration.
-        let symbolType = getAliasedSymbolTypeForName(node, symbolNameNode.value);
-        if (!symbolType) {
-            return;
+        if (node.isWildcardImport) {
+            // Write back a dummy type so we don't evaluate this node again.
+            writeTypeCache(node, { type: types_1.AnyType.create() }, 0 /* None */);
+            const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+            if (flowNode && (flowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) !== 0) {
+                const wildcardFlowNode = flowNode;
+                wildcardFlowNode.names.forEach((name) => {
+                    var _a, _b;
+                    const importedSymbolType = getAliasedSymbolTypeForName(node, name);
+                    if (!importedSymbolType) {
+                        return;
+                    }
+                    const symbolWithScope = lookUpSymbolRecursive(node, name, /* honorCodeFlow */ false);
+                    if (!symbolWithScope) {
+                        return;
+                    }
+                    const declaredType = (_a = getDeclaredTypeOfSymbol(symbolWithScope.symbol)) === null || _a === void 0 ? void 0 : _a.type;
+                    if (!declaredType) {
+                        return;
+                    }
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    if (!assignType(declaredType, importedSymbolType, diagAddendum)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatchWildcard().format({
+                            ...printSrcDestTypes(importedSymbolType, declaredType),
+                            name,
+                        }) + diagAddendum.getString(), node, (_b = node.wildcardToken) !== null && _b !== void 0 ? _b : node);
+                    }
+                });
+            }
         }
-        // Is there a cached module type associated with this node? If so, use
-        // it instead of the type we just created.
-        const cachedModuleType = readTypeCache(node, 0 /* None */);
-        if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
-            if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
-                symbolType = cachedModuleType;
+        else {
+            // Use the first element of the name parts as the symbol.
+            const symbolNameNode = node.module.nameParts[0];
+            // Look up the symbol to find the alias declaration.
+            let symbolType = getAliasedSymbolTypeForName(node, symbolNameNode.value);
+            if (!symbolType) {
+                return;
+            }
+            // Is there a cached module type associated with this node? If so, use
+            // it instead of the type we just created.
+            const cachedModuleType = readTypeCache(node, 0 /* None */);
+            if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
+                if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
+                    symbolType = cachedModuleType;
+                }
             }
+            assignTypeToNameNode(symbolNameNode, symbolType, 
+            /* isIncomplete */ false, 
+            /* ignoreEmptyContainers */ false);
+            writeTypeCache(node, { type: symbolType }, 0 /* None */);
         }
-        assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForTypeAnnotationNode(node) {
         var _a;
@@ -13029,14 +13114,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         nodeToEvaluate = parent;
                         continue;
                     }
-                    flags = 2 /* DoNotSpecialize */;
+                    flags = 16777218 /* CallBaseDefaults */;
                     break;
                 }
             }
             else if (parent.nodeType === 24 /* Index */) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
-                    flags = 2 /* DoNotSpecialize */;
+                    flags = 2 /* IndexBaseDefaults */;
                     break;
                 }
             }
@@ -13643,6 +13728,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     if ((0, types_1.isParamSpec)(typeArg)) {
                                         functionType.details.paramSpec = typeArg;
                                     }
+                                    else if ((0, typeUtils_1.isEllipsisType)(typeArg)) {
+                                        types_1.FunctionType.addDefaultParameters(functionType);
+                                        functionType.details.flags |=
+                                            32768 /* SkipArgsKwargsCompatibilityCheck */;
+                                    }
                                 }
                                 else {
                                     types_1.FunctionType.addParameter(functionType, {
@@ -13742,8 +13832,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let flags = 128 /* ExpectingInstantiableType */ |
             8 /* EvaluateStringLiteralAsType */ |
             131072 /* DisallowClassVar */;
-        if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
-            flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
+        if (options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId) {
+            flags |= 4096 /* AllowTypeVarsWithoutScopeId */;
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile || (options === null || options === void 0 ? void 0 : options.allowForwardReference)) {
@@ -14481,7 +14571,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Special-case calls to certain built-in type functions.
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
-                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* DoNotSpecialize */);
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 16777218 /* CallBaseDefaults */);
                     const callType = baseTypeResult.type;
                     const exemptBuiltins = [
                         'TypeVar',
@@ -14537,7 +14627,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.TypeBase.isInstantiable(inferredType) &&
                     !(0, types_1.isUnknown)(inferredType) &&
                     !(0, typeUtils_1.isEllipsisType)(inferredType)) {
-                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node);
+                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
+                    /* isPep695Syntax */ false);
                     isUnambiguousType = true;
                 }
             }
@@ -14972,6 +15063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return types_1.UnknownType.create();
     }
     function getFunctionInferredReturnType(type, args) {
+        var _a;
         let returnType;
         let isIncomplete = false;
         let analyzeUnannotatedFunctions = true;
@@ -15039,9 +15131,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
             args) {
-            const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
-            if (contextualReturnType) {
-                returnType = contextualReturnType;
+            let hasDecorators = false;
+            let isAsync = false;
+            const declNode = (_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.node;
+            if (declNode) {
+                if (declNode.decorators.length > 0) {
+                    hasDecorators = true;
+                }
+                if (declNode.isAsync) {
+                    isAsync = true;
+                }
+            }
+            // We can't use this technique if decorators or async are used because they
+            // would need to be applied to the inferred return type.
+            if (!hasDecorators && !isAsync) {
+                const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
+                if (contextualReturnType) {
+                    returnType = contextualReturnType;
+                }
             }
         }
         return returnType;
@@ -17007,16 +17114,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // concatenated parameters must match.
         if (targetIncludesParamSpec &&
             ((_j = srcType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope) === ((_k = destType.details.paramSpec) === null || _k === void 0 ? void 0 : _k.nameWithScope)) {
-            const srcParamCount = srcType.details.parameters.length;
-            const destParamCount = destType.details.parameters.length;
-            if (srcParamCount !== destParamCount) {
-                // If the dest has an extra position-only parameter separator appended
-                // to the end of the signature, it's OK.
-                if (srcParamCount !== destParamCount - 1 ||
-                    destType.details.parameters[destParamCount - 1].category !== 0 /* Simple */ ||
-                    !!destType.details.parameters[destParamCount - 1].name) {
-                    canAssign = false;
-                }
+            if (srcParamDetails.params.length !== destParamDetails.params.length) {
+                canAssign = false;
             }
         }
         const effectiveSrcTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcTypeVarContext : destTypeVarContext;
@@ -17076,6 +17175,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* SynthesizedMethod */, effectiveSrcType.details.docString);
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
+                    remainingFunction.details.constructorTypeVarScopeId =
+                        effectiveSrcType.details.constructorTypeVarScopeId;
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
@@ -17174,7 +17275,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParam = assignedType.details.typeParameters[index];
                 const expectedTypeArgType = typeVarContext.getPrimarySignature().getTypeVarType(typeParam);
                 if (expectedTypeArgType) {
-                    if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
+                    if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
                         replacedTypeArg = true;
                         return expectedTypeArgType;
                     }
@@ -17186,6 +17287,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return recursiveReplacement;
                         }
                     }
+                    else if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType)) {
+                        // If the expected type arg contains an Any, we can replace it with
+                        // a version that doesn't contain Any if the replacement doesn't violate
+                        // the variance of the type parameter.
+                        const variance = types_1.TypeVarType.getVariance(typeParam);
+                        const isSubtype = assignType(expectedTypeArgType, typeArg);
+                        const isSupertype = assignType(typeArg, expectedTypeArgType);
+                        if ((variance === 4 /* Contravariant */ || isSubtype) &&
+                            (variance === 3 /* Covariant */ || isSupertype)) {
+                            replacedTypeArg = true;
+                            return expectedTypeArgType;
+                        }
+                    }
                 }
                 return typeArg;
             });
@@ -17193,6 +17307,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.ClassType.cloneForSpecialization(assignedType, newTypeArgs, /* isTypeArgumentExplicit */ true);
             }
         }
+        // If the declared and assigned types are the same generic type but the assigned type
+        // contains one or more unknowns, use the declared type instead.
+        if (types_1.ClassType.isSameGenericClass(declaredType, assignedType)) {
+            if ((0, typeUtils_1.containsAnyRecursive)(assignedType) && !(0, typeUtils_1.containsAnyRecursive)(declaredType)) {
+                return declaredType;
+            }
+        }
         return undefined;
     }
     // When a value is assigned to a variable with a declared type,
@@ -17205,29 +17326,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return declaredSubtype;
                 }
                 if (assignType(declaredSubtype, assignedSubtype)) {
-                    // If the source is generic and has unspecified type arguments,
-                    // see if we can determine them based on the declared type.
-                    if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
+                    // If the assigned subtype is Any, stick with the declared type.
+                    if ((0, types_1.isAny)(assignedSubtype)) {
+                        return declaredSubtype;
+                    }
+                    if ((0, types_1.isClass)(declaredSubtype) &&
+                        (0, types_1.isClass)(assignedSubtype) &&
+                        types_1.TypeBase.isInstance(declaredSubtype) === types_1.TypeBase.isInstance(assignedSubtype)) {
                         const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
                         if (result) {
                             assignedSubtype = result;
                         }
+                        return assignedSubtype;
                     }
-                    else if ((0, types_1.isClassInstance)(declaredSubtype) && (0, types_1.isClassInstance)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(node, types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
-                        if (result) {
-                            assignedSubtype = types_1.ClassType.cloneAsInstance(result);
-                        }
-                    }
-                    else if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
+                    if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
                         // If the source is an unsolved TypeVar but the declared type is concrete,
                         // use the concrete type.
                         return declaredSubtype;
                     }
-                    // If the assigned subtype is Any, stick with the declared type.
-                    if ((0, types_1.isAny)(assignedSubtype)) {
-                        return declaredSubtype;
-                    }
                     // If the declared type doesn't contain any `Any` but the assigned
                     // type does, stick with the declared type.
                     if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
@@ -17295,28 +17411,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // must all match and be in the correct order. It is OK if the base method
         // has additional overloads that are not present in the override.
         let previousMatchIndex = -1;
-        let overrideOverloadIndex = 0;
         const baseOverloads = types_1.OverloadedFunctionType.getOverloads(baseMethod);
         for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
-            const matchIndex = baseOverloads.findIndex((baseOverload) => {
+            let possibleMatchIndex;
+            let matchIndex = baseOverloads.findIndex((baseOverload, index) => {
                 // If the override isn't applicable for this base class, skip the check.
                 if (baseClass && !isOverrideMethodApplicable(baseOverload, baseClass)) {
                     return false;
                 }
-                return validateOverrideMethodInternal(baseOverload, overrideOverload, 
+                const isCompatible = validateOverrideMethodInternal(baseOverload, overrideOverload, 
                 /* diag */ undefined, enforceParamNames, 
                 /* exemptSelfClsParam */ false);
+                // If the override is compatible but the match is one that is below the previous
+                // matched index, keep looking for additional matches. Record the fact that
+                // we found at least one match.
+                if (isCompatible && index <= previousMatchIndex && possibleMatchIndex === undefined) {
+                    possibleMatchIndex = index;
+                    return false;
+                }
+                return isCompatible;
             });
+            if (matchIndex < 0 && possibleMatchIndex !== undefined) {
+                matchIndex = possibleMatchIndex;
+            }
             if (matchIndex < 0) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex + 1 }));
-                return false;
+                continue;
             }
             if (matchIndex < previousMatchIndex) {
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
                 return false;
             }
             previousMatchIndex = matchIndex;
-            overrideOverloadIndex++;
+        }
+        if (previousMatchIndex < baseOverloads.length - 1) {
+            // We didn't find matches for all of the base overloads.
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch());
+            return false;
         }
         return true;
     }
@@ -17586,9 +17716,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Verify that one or the other method doesn't contain a ParamSpec.
-        if (baseMethod.details.paramSpec && !overrideMethod.details.paramSpec) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
-            canOverride = false;
+        if (baseParamDetails.paramSpec && !overrideParamDetails.paramSpec) {
+            // If the override uses an `*args: Any, **kwargs: Any` signature, we
+            // will allow this as an acceptable overload for a `*args: P.args, **kwargs: P.kwargs`.
+            const overrideHasArgsKwargs = overrideParamDetails.argsIndex !== undefined &&
+                (0, types_1.isAnyOrUnknown)(overrideParamDetails.params[overrideParamDetails.argsIndex].type) &&
+                overrideParamDetails.kwargsIndex !== undefined &&
+                (0, types_1.isAnyOrUnknown)(overrideParamDetails.params[overrideParamDetails.kwargsIndex].type);
+            if (!overrideHasArgsKwargs) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+                canOverride = false;
+            }
         }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);