@zzzen/pyright-internal 1.2.0-dev.20231126 → 1.2.0-dev.20231203

package/dist/analyzer/typeEvaluator.js

@@ -735,15 +735,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    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.
@@ -770,7 +761,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         const effectiveExpectedType = inferenceContext
-            ? createAwaitableReturnType(node, inferenceContext.expectedType, /* isGenerator */ false)
+            ? createAwaitableReturnType(node, inferenceContext.expectedType, 
+            /* isGenerator */ false, 
+            /* useCoroutine */ false)
             : undefined;
         const exprTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
         const typeResult = {
@@ -2484,9 +2477,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 types_1.FunctionType.addDefaultParameters(concreteFunction);
                 return types_1.FunctionType.cloneForParamSpec(subtype, concreteFunction);
             }
-            // If this is a TypeVarTuple *Ts, convert it to an unpacked tuple
-            // *tuple[*Ts].
-            if ((0, types_1.isVariadicTypeVar)(subtype)) {
+            if ((0, types_1.isTypeVar)(subtype) && subtype.details.isVariadic) {
                 // If it's in a union, convert to type or object.
                 if (subtype.isVariadicInUnion) {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
@@ -2499,11 +2490,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return types_1.AnyType.create();
                 }
-                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: subtype, isUnbounded: false }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* isUnpackedTuple */ true));
-                }
+                return subtype;
             }
             if ((0, types_1.isTypeVar)(subtype) && !subtype.details.recursiveTypeAliasName) {
                 // If this is a recursive type alias placeholder
@@ -2555,7 +2542,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isConstrainedTypeVar: false,
                     },
                 ]);
-                return types_1.AnyType.create();
             }
             return subtype;
         });
@@ -2591,7 +2577,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeCondition && typeCondition.length > 0) {
                         transformedType = (0, typeUtils_1.addConditionToType)(transformedType, typeCondition);
                     }
-                    newSubtypes.push(transformedType);
+                    // This code path can often produce many duplicate subtypes. We can
+                    // reduce the cost of the combineTypes call below by filtering out these
+                    // duplicates proactively.
+                    if (newSubtypes.length === 0 ||
+                        !(0, types_1.isTypeSame)(transformedType, newSubtypes[newSubtypes.length - 1])) {
+                        newSubtypes.push(transformedType);
+                    }
                 }
                 return undefined;
             }, sortSubtypes);
@@ -2873,6 +2865,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfName(node, flags) {
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3024,9 +3017,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
-        if ((flags & 16777216 /* EvaluatorFlags.DisallowPep695TypeAlias */) !== 0) {
-            if (reportInvalidUseOfPep695TypeAlias(type, node)) {
-                type = types_1.UnknownType.create();
+        if ((flags & 16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */) !== 0) {
+            if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax && types_1.TypeBase.isSpecialForm(type)) {
+                const typeAliasType = getTypingType(node, 'TypeAliasType');
+                if (typeAliasType && (0, types_1.isInstantiableClass)(typeAliasType)) {
+                    type = types_1.ClassType.cloneAsInstance(typeAliasType);
+                }
+                else {
+                    type = types_1.UnknownType.create();
+                }
             }
         }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
@@ -3470,7 +3469,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cases where a type is passed as an argument (e.g. "defaultdict(list)").
         // It can also come up in cases like "isinstance(x, (list, dict))".
         // We need to check for functions as well to handle Callable.
-        if ((0, types_1.isInstantiableClass)(typeResult.type) || (0, types_1.isFunction)(typeResult.type)) {
+        if ((0, types_1.isInstantiableClass)(typeResult.type) ||
+            ((0, types_1.isFunction)(typeResult.type) && types_1.TypeBase.isSpecialForm(typeResult.type))) {
             const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* ParseNodeType.Argument */);
             if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
                 skipPartialUnknownCheck = true;
@@ -3486,7 +3486,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
         var _a, _b;
-        let baseType = baseTypeResult.type;
+        let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4071,7 +4071,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (types_1.ClassType.isClassProperty(concreteMemberType)) {
             // Handle "class properties" as a special case. We need to pass
             // the class rather than the object instance in this case.
-            objArgType = classType;
+            objArgType = isAccessedThroughObject ? types_1.ClassType.cloneAsInstantiable(classType) : classType;
         }
         else if (isAccessedThroughObject) {
             objArgType = selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType);
@@ -4357,7 +4357,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags & ~16777216 /* EvaluatorFlags.DisallowPep695TypeAlias */);
+        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags & ~16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // We limit type narrowing for index expressions to built-in types that are
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
@@ -6913,7 +6913,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         tooManyPositionals = true;
                     }
                     if (tooManyPositionals) {
-                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
                                 ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
                                 : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
@@ -6946,7 +6946,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isTypeVar)(argTypeResult.type) &&
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
-                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
                                 ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
                                 : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
@@ -7013,7 +7013,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // It's not allowed to use unpacked arguments with a variadic *args
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
-                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                    if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
@@ -7070,7 +7070,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         : 0 /* ParameterCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
-                            if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                 // Have we run out of arguments and still have parameters left to fill?
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
                                     ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
@@ -7153,7 +7153,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argsRemainingCount--;
             }
             if (argsRemainingCount > 0) {
-                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
                         ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
                         : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
@@ -7235,7 +7235,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         });
                         if (!diag.isEmpty()) {
-                            if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
@@ -7296,7 +7296,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 });
                             }
                             if (!isValidMappingType) {
-                                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
                                         .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
@@ -7318,7 +7318,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const paramEntry = paramMap.get(paramNameValue);
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
+                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet
+                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
+                                }
                                 reportedArgError = true;
                             }
                             else {
@@ -7360,7 +7363,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
                         else {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: paramName.value }), paramName);
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(paramName).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: paramName.value }), paramName);
+                            }
                             reportedArgError = true;
                         }
                     }
@@ -7369,9 +7374,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramSpecArgList.push(argList[argIndex]);
                         }
                         else {
-                            if (!isDiagnosticSuppressedForNode(errorNode)) {
-                                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
                                     ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
                                     : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
                                         expected: positionParamLimitIndex,
@@ -7447,9 +7451,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (unassignedParams.length > 0) {
                     if (!isDiagnosticSuppressedForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                            ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                            : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                                ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
+                                : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                        }
                     }
                     reportedArgError = true;
                 }
@@ -7515,14 +7521,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (containsVariadicTypeVar &&
                                 argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
                                 !argParam.mapsToVarArgList) {
-                                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
                                         .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                                 }
                                 reportedArgError = true;
                             }
                             return {
-                                type: stripLiteralValue(argType),
+                                type: argType,
                                 isUnbounded: argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */,
                             };
                         });
@@ -8179,7 +8185,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
                         64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16777216 /* EvaluatorFlags.DisallowPep695TypeAlias */
+                        16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */
                     : 2 /* EvaluatorFlags.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;
@@ -8377,21 +8383,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const diagAddendum = getDiagAddendum();
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportUnknownArgumentType, diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType, localize_1.Localizer.Diagnostic.argTypeUnknown() + diagAddendum.getString(), argParam.errorNode);
                 }
-                else if ((0, typeUtils_1.isPartlyUnknown)(simplifiedType, /* allowUnknownTypeArgsForClasses */ true)) {
-                    let suppressPartialUnknown = false;
-                    // Don't report an error if the type is a partially-specialized
-                    // class. This comes up frequently in cases where a type is passed
-                    // as an argument (e.g. "defaultdict(list)").
-                    if ((0, types_1.isInstantiableClass)(simplifiedType)) {
-                        suppressPartialUnknown = true;
-                    }
+                else if ((0, typeUtils_1.isPartlyUnknown)(simplifiedType)) {
                     // If the parameter type is also partially unknown, don't report
                     // the error because it's likely that the partially-unknown type
                     // arose due to bidirectional type matching.
-                    if ((0, typeUtils_1.isPartlyUnknown)(argParam.paramType)) {
-                        suppressPartialUnknown = true;
-                    }
-                    if (!suppressPartialUnknown) {
+                    if (!(0, typeUtils_1.isPartlyUnknown)(argParam.paramType)) {
                         const diagAddendum = getDiagAddendum();
                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentType().format({
                             type: printType(simplifiedType, { expandTypeAlias: true }),
@@ -9655,6 +9651,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     paramType = getTypeOfExpression(param.defaultValue, undefined, inferenceContext).type;
                 }
             }
+            else if (param.defaultValue) {
+                // If there is no inference context but we have a default value,
+                // use the default value to infer the parameter's type.
+                paramType = inferParameterTypeFromDefaultValue(param.defaultValue);
+            }
             if (param.name) {
                 writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* EvaluatorFlags.None */);
             }
@@ -10266,7 +10267,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return types_1.ClassType.cloneForSpecialization(classType, convertedTypeArgs, /* isTypeArgumentExplicit */ true);
     }
-    function createSelfType(classType, errorNode, typeArgs) {
+    function createSelfType(classType, errorNode, typeArgs, flags) {
         var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         // Self doesn't support any type arguments.
@@ -10278,7 +10279,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const enclosingClass = ParseTreeUtils.getEnclosingClass(errorNode);
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
-            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
+            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
+            }
             return types_1.UnknownType.create();
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
@@ -11168,7 +11171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */ |
                 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */ |
                 16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */ |
-                16777216 /* EvaluatorFlags.DisallowPep695TypeAlias */;
+                16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */;
             if (fileInfo.isStubFile) {
                 exprFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
             }
@@ -11271,10 +11274,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
                         }
                         // Determine if the class is abstract. Protocol classes support abstract methods
-                        // even though they don't derive from the ABCMeta class. We'll exclude built-in
-                        // protocol classes because these are known not to contain any abstract methods
-                        // and getAbstractMethods causes problems because of dependencies on some of these
-                        // built-in protocol classes.
+                        // because they are constructed by the _ProtocolMeta metaclass, which derives
+                        // from ABCMeta. We'll exclude built-in protocol classes because these are known
+                        // not to contain any abstract methods and getAbstractMethods causes problems
+                        // because of dependencies on some of these built-in protocol classes.
                         if (types_1.ClassType.supportsAbstractMethods(argType) ||
                             (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
                             classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
@@ -11972,6 +11975,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // function declaration falls within an unreachable code block.
                 return undefined;
             }
+            if (types_1.FunctionType.isPartiallyEvaluated(functionType)) {
+                return { functionType, decoratedType: functionType };
+            }
         }
         else {
             functionType = getTypeOfFunctionPredecorated(node);
@@ -12128,7 +12134,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         node.parameters.forEach((param, index) => {
             let paramType;
             let annotatedType;
-            let isNoneWithoutOptional = false;
             let paramTypeNode;
             if (param.name) {
                 if (index === 0 && isFirstParamClsOrSelf) {
@@ -12176,7 +12181,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const adjustedAnnotatedType = adjustParameterAnnotatedType(param, annotatedType);
                 if (adjustedAnnotatedType !== annotatedType) {
                     annotatedType = adjustedAnnotatedType;
-                    isNoneWithoutOptional = true;
                 }
             }
             let defaultValueType;
@@ -12205,17 +12209,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
-                        const diag = addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAssignmentMismatch().format({
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAssignmentMismatch().format({
                             sourceType: printType(defaultValueType),
                             paramType: printType(annotatedType),
                         }) + diagAddendum.getString(), param.defaultValue);
-                        if (isNoneWithoutOptional && paramTypeNode) {
-                            const addOptionalAction = {
-                                action: "pyright.addoptionalforparam" /* Commands.addMissingOptionalToParam */,
-                                offsetOfTypeNode: paramTypeNode.start + 1,
-                            };
-                            diag === null || diag === void 0 ? void 0 : diag.addAction(addOptionalAction);
-                        }
                     }
                 }
                 paramType = annotatedType;
@@ -12474,43 +12471,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // type from this information.
         const paramValueExpr = functionNode.parameters[paramIndex].defaultValue;
         if (paramValueExpr) {
-            const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvaluatorFlags.ConvertEllipsisToAny */).type;
-            let inferredParamType;
-            // Is the default value a "None" or an instance of some private class (one
-            // whose name starts with an underscore)? If so, we will assume that the
-            // value is a singleton sentinel. The actual supported type is going to be
-            // a union of this type and Unknown.
-            if ((0, typeUtils_1.isNoneInstance)(defaultValueType) ||
-                ((0, types_1.isClassInstance)(defaultValueType) && (0, symbolNameUtils_1.isPrivateOrProtectedName)(defaultValueType.details.name))) {
-                inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
+            return inferParameterTypeFromDefaultValue(paramValueExpr);
+        }
+        return undefined;
+    }
+    function inferParameterTypeFromDefaultValue(paramValueExpr) {
+        const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvaluatorFlags.ConvertEllipsisToAny */).type;
+        let inferredParamType;
+        // Is the default value a "None" or an instance of some private class (one
+        // whose name starts with an underscore)? If so, we will assume that the
+        // value is a singleton sentinel. The actual supported type is going to be
+        // a union of this type and Unknown.
+        if ((0, typeUtils_1.isNoneInstance)(defaultValueType) ||
+            ((0, types_1.isClassInstance)(defaultValueType) && (0, symbolNameUtils_1.isPrivateOrProtectedName)(defaultValueType.details.name))) {
+            inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
+        }
+        else {
+            let skipInference = false;
+            if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloadedFunction)(defaultValueType)) {
+                // Do not infer parameter types that use a lambda or another function as a
+                // default value. We're likely to generate false positives in this case.
+                // It's not clear whether parameters should be positional-only or not.
+                skipInference = true;
             }
-            else {
-                let skipInference = false;
-                if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloadedFunction)(defaultValueType)) {
-                    // Do not infer parameter types that use a lambda or another function as a
-                    // default value. We're likely to generate false positives in this case.
-                    // It's not clear whether parameters should be positional-only or not.
-                    skipInference = true;
-                }
-                else if ((0, types_1.isClassInstance)(defaultValueType) &&
-                    types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
-                    // Do not infer certain types like tuple because it's likely to be
-                    // more restrictive (narrower) than intended.
-                    skipInference = true;
-                }
-                if (!skipInference) {
-                    inferredParamType = stripLiteralValue(defaultValueType);
-                }
+            else if ((0, types_1.isClassInstance)(defaultValueType) &&
+                types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
+                // Do not infer certain types like tuple because it's likely to be
+                // more restrictive (narrower) than intended.
+                skipInference = true;
             }
-            if (inferredParamType) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
-                if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
-                    inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
-                }
+            if (!skipInference) {
+                inferredParamType = stripLiteralValue(defaultValueType);
             }
-            return inferredParamType;
         }
-        return undefined;
+        if (inferredParamType) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(paramValueExpr);
+            if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
+                inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
+            }
+        }
+        return inferredParamType;
     }
     // Transforms the parameter type based on its category. If it's a simple parameter,
     // no transform is applied. If it's a var-arg or keyword-arg parameter, the type
@@ -12565,7 +12565,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return awaitableFunctionType;
     }
-    function createAwaitableReturnType(node, returnType, isGenerator) {
+    function createAwaitableReturnType(node, returnType, isGenerator, useCoroutine = true) {
         let awaitableReturnType;
         if ((0, types_1.isClassInstance)(returnType)) {
             if (types_1.ClassType.isBuiltIn(returnType)) {
@@ -12593,10 +12593,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!awaitableReturnType || !isGenerator) {
-            // Wrap in a Coroutine, which is a subclass of Awaitable.
-            const coroutineType = getTypingType(node, 'Coroutine');
-            if (coroutineType && (0, types_1.isInstantiableClass)(coroutineType)) {
-                awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(coroutineType, [types_1.AnyType.create(), types_1.AnyType.create(), returnType], 
+            // Wrap in either an Awaitable or a Coroutine, which is a subclass of Awaitable.
+            const awaitableType = getTypingType(node, useCoroutine ? 'Coroutine' : 'Awaitable');
+            if (awaitableType && (0, types_1.isInstantiableClass)(awaitableType)) {
+                awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(awaitableType, useCoroutine ? [types_1.AnyType.create(), types_1.AnyType.create(), returnType] : [returnType], 
                 /* isTypeArgumentExplicit */ true));
             }
             else {
@@ -13765,7 +13765,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     break;
                 }
                 case 'Self': {
-                    return { type: createSelfType(classType, errorNode, typeArgs) };
+                    return { type: createSelfType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'LiteralString': {
                     return { type: createSpecialType(classType, typeArgs, 0) };
@@ -15775,6 +15775,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
             }
         }
+        // Remove any optional parameters from the end of the two lists until the lengths match.
+        while (srcTypeArgs.length > destTypeArgs.length && srcTypeArgs[srcTypeArgs.length - 1].isOptional) {
+            srcTypeArgs.splice(srcTypeArgs.length - 1, 1);
+        }
+        while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
+            destTypeArgs.splice(destTypeArgs.length - 1, 1);
+        }
         const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
         if (destUnboundedIndex >= 0 && srcArgsToCapture >= 0) {
             // If the dest contains a variadic element, determine which source
@@ -16313,14 +16320,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeTypeArg = types_1.UnknownType.create();
             }
             if ((0, types_1.isAnyOrUnknown)(typeTypeArg)) {
-                if ((0, types_1.isClassInstance)(destType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
+                if ((0, typeUtils_1.isEffectivelyInstantiable)(destType)) {
                     return true;
                 }
-                return types_1.TypeBase.isInstantiable(destType);
             }
-            const instantiableType = (0, typeUtils_1.convertToInstantiable)(typeTypeArg);
-            if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
-                if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            else if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
+                if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -17020,15 +17025,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
             }
         }
-        // Handle the special case where the source is a Self type and the
-        // destination is not.
-        if (!(0, types_1.isTypeVar)(specializedDestType) || !specializedDestType.details.isSynthesizedSelf) {
-            if ((0, types_1.isTypeVar)(specializedSrcType) &&
-                specializedSrcType.details.isSynthesizedSelf &&
-                specializedSrcType.details.boundType) {
-                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(specializedSrcType.details.boundType, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(specializedSrcType)), { unknownIfNotFound: true });
-            }
-        }
         if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, destTypeVarContext, flags, recursionCount)) {
             // There are cases involving lambdas where the parameter types are type
             // variables and match exactly but fail the assignment check because the
@@ -17089,7 +17085,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
-                srcTupleTypes.push({ type: entry.type, isUnbounded: false });
+                srcTupleTypes.push({ type: entry.type, isUnbounded: false, isOptional: entry.param.hasDefault });
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isVariadicTypeVar)(srcTupleTypes[0].type)) {
@@ -18118,7 +18114,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let bestConstraintSoFar;
             // Try to find the best (narrowest) match among the constraints.
             for (const constraint of constraints) {
-                if (assignType(constraint, effectiveSrcType)) {
+                // Don't allow Never as a type argument.
+                if (assignType(constraint, effectiveSrcType) && !(0, types_1.isNever)(effectiveSrcType)) {
                     if (!bestConstraintSoFar || assignType(bestConstraintSoFar, constraint)) {
                         bestConstraintSoFar = constraint;
                     }