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

package/dist/analyzer/typeEvaluator.js

@@ -47,6 +47,7 @@ const diagnosticRules_1 = require("../common/diagnosticRules");
 const positionUtils_1 = require("../common/positionUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const textRange_1 = require("../common/textRange");
+const uri_1 = require("../common/uri/uri");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const parser_1 = require("../parser/parser");
@@ -262,7 +263,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const message = `Type cache flag mismatch for node type ${node.nodeType} ` +
                         `(parent ${(_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== null && _b !== void 0 ? _b : 'none'}): ` +
                         `cached flags = ${expectedFlags}, access flags = ${flags}, ` +
-                        `file = {${fileInfo.filePath} [${position.line + 1}:${position.character + 1}]}`;
+                        `file = {${fileInfo.fileUri} [${position.line + 1}:${position.character + 1}]}`;
                     if (evaluatorOptions.verifyTypeCacheEvaluatorFlags) {
                         (0, debug_1.fail)(message);
                     }
@@ -735,15 +736,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 +762,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 = {
@@ -1414,9 +1408,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
-            const unknownFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-            types_1.FunctionType.addDefaultParameters(unknownFunction);
-            return unknownFunction;
+            return (0, typeUtils_1.getUnknownTypeForCallable)();
         }
         return undefined;
     }
@@ -1930,7 +1922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfModule(node, symbolName, nameParts) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        const lookupResult = importLookup({ nameParts, importingFilePath: fileInfo.filePath });
+        const lookupResult = importLookup({ nameParts, importingFileUri: fileInfo.fileUri });
         if (!lookupResult) {
             return undefined;
         }
@@ -2480,13 +2472,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isFunction)(subtype) &&
                 subtype.details.parameters.length === 0 &&
                 subtype.details.paramSpec) {
-                const concreteFunction = types_1.FunctionType.createInstance('', '', '', 64 /* FunctionTypeFlags.SynthesizedMethod */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-                types_1.FunctionType.addDefaultParameters(concreteFunction);
-                return types_1.FunctionType.cloneForParamSpec(subtype, concreteFunction);
+                return types_1.FunctionType.cloneForParamSpec(subtype, (0, typeUtils_1.getUnknownTypeForCallable)());
             }
-            // 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 +2487,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 +2539,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isConstrainedTypeVar: false,
                     },
                 ]);
-                return types_1.AnyType.create();
             }
             return subtype;
         });
@@ -2591,7 +2574,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 +2862,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfName(node, flags) {
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3024,9 +3014,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) {
@@ -3073,7 +3069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return type;
     }
     // Handles the case where a variable or parameter is defined in an outer
-    // scope and captured by an inner scope (either a function or a lambda).
+    // scope and captured by an inner scope (a function, lambda, or comprehension).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
         // This function applies only to variables, parameters, and imports, not to other
         // types of symbols.
@@ -3093,16 +3089,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the symbol is a variable captured by an inner function
         // or lambda, see if we can infer the type from the outer scope.
         const scopeHierarchy = ScopeUtils.getScopeHierarchy(node, symbolWithScope.scope);
-        // Handle the case where all of the nested scopes are functions,
-        // lambdas and modules. Don't allow other types of scopes.
-        if (scopeHierarchy &&
-            scopeHierarchy.length >= 2 &&
-            scopeHierarchy.every((s) => s.type === 1 /* ScopeType.Function */ || s.type === 3 /* ScopeType.Module */)) {
+        if (scopeHierarchy && scopeHierarchy.length >= 2) {
             // Find the parse node associated with the scope that is just inside of the
             // scope that declares the captured variable.
             const innerScopeNode = ScopeUtils.findTopNodeInScope(node, scopeHierarchy[scopeHierarchy.length - 2]);
-            if (innerScopeNode &&
-                (innerScopeNode.nodeType === 28 /* ParseNodeType.Function */ || innerScopeNode.nodeType === 30 /* ParseNodeType.Lambda */)) {
+            if ((innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 28 /* ParseNodeType.Function */ ||
+                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 30 /* ParseNodeType.Lambda */ ||
+                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 10 /* ParseNodeType.Class */) {
                 const innerScopeCodeFlowNode = AnalyzerNodeInfo.getFlowNode(innerScopeNode);
                 if (innerScopeCodeFlowNode) {
                     // See if any of the assignments of the symbol are reachable
@@ -3470,7 +3463,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 +3480,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);
@@ -3624,9 +3618,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const getAttrSymbol = types_1.ModuleType.getField(baseType, '__getattr__');
                         if (getAttrSymbol) {
                             const isModuleGetAttrSupported = fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_7 ||
-                                getAttrSymbol
-                                    .getDeclarations()
-                                    .some((decl) => decl.path.toLowerCase().endsWith('.pyi'));
+                                getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
@@ -4071,7 +4063,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 +4349,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
@@ -5706,9 +5698,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
-        const enclosingClass = enclosingFunction
-            ? ParseTreeUtils.getEnclosingClass(enclosingFunction, /* stopAtFunction */ true)
-            : undefined;
+        const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
         const enclosingClassType = enclosingClass ? (_a = getTypeOfClass(enclosingClass)) === null || _a === void 0 ? void 0 : _a.classType : undefined;
         // Determine which class the "super" call is applied to. If
         // there is no first argument, then the class is implicit.
@@ -5771,6 +5761,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (reportError) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
+                return { type: types_1.UnknownType.create() };
             }
         }
         else if (enclosingClassType) {
@@ -5838,34 +5829,77 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const lookupResults = bindToType
                 ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* MemberAccessFlags.Default */, effectiveTargetClass)
                 : undefined;
+            let resultType;
             if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
-                return {
-                    type: resultIsInstance
-                        ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
-                        : lookupResults.classType,
-                    bindToSelfType: bindToType
-                        ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
-                        : undefined,
-                };
+                resultType = lookupResults.classType;
+            }
+            else if (effectiveTargetClass &&
+                !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
+                !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass) &&
+                objectType &&
+                (0, types_1.isClassInstance)(objectType)) {
+                resultType = types_1.ClassType.cloneAsInstantiable(objectType);
             }
+            else {
+                resultType = types_1.UnknownType.create();
+            }
+            return {
+                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType) : resultType,
+                bindToSelfType: bindToType
+                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
+                    : undefined,
+            };
         }
-        // If the lookup failed, try to return the first base class. An error
-        // will be reported by the member lookup logic at a later time.
+        // Handle the super() call when used outside of a member access expression.
         if ((0, types_1.isInstantiableClass)(targetClassType)) {
-            // If the class derives from one or more unknown classes,
-            // return unknown here to prevent spurious errors.
-            if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
-                return { type: types_1.UnknownType.create() };
-            }
-            const baseClasses = targetClassType.details.baseClasses;
-            if (baseClasses.length > 0) {
-                const baseClassType = baseClasses[0];
-                if ((0, types_1.isInstantiableClass)(baseClassType)) {
+            // We don't know which member is going to be accessed, so we cannot
+            // deterministically determine the correct type in this case. We'll
+            // use a heuristic that produces the "correct" (desired) behavior in
+            // most cases. If there's a bindToType and the targetClassType is one
+            // of the base classes of the bindToType, we'll return the next base
+            // class.
+            if (bindToType) {
+                let nextBaseClassType;
+                if (types_1.ClassType.isSameGenericClass(bindToType, targetClassType)) {
+                    if (bindToType.details.baseClasses.length > 0) {
+                        nextBaseClassType = bindToType.details.baseClasses[0];
+                    }
+                }
+                else {
+                    const baseClassIndex = bindToType.details.baseClasses.findIndex((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isSameGenericClass(baseClass, targetClassType));
+                    if (baseClassIndex >= 0 && baseClassIndex < bindToType.details.baseClasses.length - 1) {
+                        nextBaseClassType = bindToType.details.baseClasses[baseClassIndex + 1];
+                    }
+                }
+                if (nextBaseClassType) {
+                    if ((0, types_1.isInstantiableClass)(nextBaseClassType)) {
+                        nextBaseClassType = (0, typeUtils_1.specializeForBaseClass)(bindToType, nextBaseClassType);
+                    }
+                    return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
+                }
+                // There's not much we can say about the type. Simply return object or type.
+                if (objectType && (0, types_1.isClassInstance)(objectType) && typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
                     return {
-                        type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
+                        type: resultIsInstance ? objectType : (0, typeUtils_1.convertToInstance)(typeClassType),
                     };
                 }
             }
+            else {
+                // If the class derives from one or more unknown classes,
+                // return unknown here to prevent spurious errors.
+                if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
+                    return { type: types_1.UnknownType.create() };
+                }
+                const baseClasses = targetClassType.details.baseClasses;
+                if (baseClasses.length > 0) {
+                    const baseClassType = baseClasses[0];
+                    if ((0, types_1.isInstantiableClass)(baseClassType)) {
+                        return {
+                            type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
+                        };
+                    }
+                }
+            }
         }
         return { type: types_1.UnknownType.create() };
     }
@@ -6183,7 +6217,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const diagnostic = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }), errorNode);
                 const overrideDecl = bestMatch.overload.details.declaration;
                 if (diagnostic && overrideDecl) {
-                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.path, overrideDecl.range);
+                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
                 }
             }
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
@@ -6663,7 +6697,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     newClassName = firstArgType.literalValue;
                 }
             }
-            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
+            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
             newClassType.details.baseClasses.push(getBuiltInType(errorNode, 'object'));
             newClassType.details.effectiveMetaclass = expandedCallType;
             (0, typeUtils_1.computeMroLinearization)(newClassType);
@@ -6913,7 +6947,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 +6980,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 +7047,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 +7104,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 +7187,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 +7269,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 +7330,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 +7352,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 +7397,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 +7408,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 +7485,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 +7555,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 */,
                             };
                         });
@@ -7605,7 +7645,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
         let effectiveExpectedType = inferenceContext.expectedType;
-        let effectiveFlags = 0 /* AssignTypeFlags.Default */;
+        let effectiveFlags = 1024 /* AssignTypeFlags.PopulatingExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(effectiveExpectedType, /* includeTypeArgs */ true)) {
             effectiveFlags |= 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
@@ -7617,7 +7657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeVarContextCopy = typeVarContext.clone();
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
-                /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* AssignTypeFlags.PopulatingExpectedType */);
+                /* srcTypeVarContext */ undefined, effectiveFlags);
                 const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, signatureTracker, skipUnknownArgCheck);
                 if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
                     effectiveExpectedType = undefined;
@@ -7663,6 +7703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
                             unknownIfNotFound: true,
                         });
+                        effectiveFlags |= 2048 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
                     }
                 }
             }
@@ -7678,7 +7719,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes, errorNode.start);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
-            /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* AssignTypeFlags.PopulatingExpectedType */);
+            /* srcTypeVarContext */ undefined, effectiveFlags);
         }
         return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
     }
@@ -8179,7 +8220,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 +8418,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 }),
@@ -8755,7 +8786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
         /* isPep695Syntax */ false, 
-        /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
+        /* typeParamNodes */ undefined, () => typeParameters);
     }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* ParseNodeType.Constant */) {
@@ -8823,7 +8854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
         classFlags |= 4096 /* ClassTypeFlags.Final */;
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
         (0, typeUtils_1.computeMroLinearization)(classType);
@@ -8870,7 +8901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
@@ -9655,6 +9686,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 +10302,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 +10314,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);
@@ -10653,7 +10691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, typeParameters, typeParamNodes) {
+    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, isPep695TypeVarType, typeParameters, typeParamNodes) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -10698,24 +10736,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: variadics.map((v) => `"${v.details.name}"`).join(', '),
             }), errorNode);
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* TypeVarScopeType.Class */);
-        if (boundTypeVars.length > 0) {
-            addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
-                names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
-            }), errorNode);
+        if (!isPep695Syntax && !isPep695TypeVarType) {
+            const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* TypeVarScopeType.Class */);
+            if (boundTypeVars.length > 0) {
+                addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
+                    names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
+                }), errorNode);
+            }
         }
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
         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) {
+        if (isPep695Syntax || isPep695TypeVarType) {
             typeAlias.flags |= 8 /* TypeFlags.SpecialForm */;
         }
         return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        let specialClassType = types_1.ClassType.createInstantiable(assignedName, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, assignedName), fileInfo.moduleName, fileInfo.filePath, 1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */, 
+        let specialClassType = types_1.ClassType.createInstantiable(assignedName, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, assignedName), fileInfo.moduleName, fileInfo.fileUri, 1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */, 
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
@@ -10964,7 +11004,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
                         // If this is a type alias, record its name based on the assignment target.
                         rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
-                        /* isPep695Syntax */ false);
+                        /* isPep695Syntax */ false, 
+                        /* isPep695TypeVarType */ false);
                         (0, debug_1.assert)(typeAliasTypeVar !== undefined);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
@@ -11021,11 +11062,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         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);
+                return evaluateTypeParameterList(node.typeParameters);
             }
-            return typeParameters;
+            return undefined;
         });
     }
     // This function is common to the handling of "type" statements and explicit
@@ -11064,7 +11104,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, typeParameters, typeParamNodes);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, 
+        /* isPep695TypeVarType */ true, 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,
@@ -11125,7 +11166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (fileInfo.isStubFile) {
             classFlags |= 8388608 /* ClassTypeFlags.DefinedInStub */;
         }
-        const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.filePath, classFlags, 
+        const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.suite.statements));
@@ -11168,7 +11209,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 +11312,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 */;
@@ -11666,7 +11707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Replace all of the type parameters with invariant TypeVars.
         const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
-        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', '', 0, 0, undefined, undefined);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         updatedTypeParams.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
             if (param.details.isVariadic || param.details.isParamSpec) {
@@ -11949,7 +11990,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (diag && initSubclassDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.initSubclassLocation().format({
                                 name: printType((0, typeUtils_1.convertToInstance)(initSubclassMethodInfo.classType)),
-                            }), initSubclassDecl.path, initSubclassDecl.range);
+                            }), initSubclassDecl.uri, initSubclassDecl.range);
                         }
                     }
                 }
@@ -11972,6 +12013,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 +12172,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 +12219,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const adjustedAnnotatedType = adjustParameterAnnotatedType(param, annotatedType);
                 if (adjustedAnnotatedType !== annotatedType) {
                     annotatedType = adjustedAnnotatedType;
-                    isNoneWithoutOptional = true;
                 }
             }
             let defaultValueType;
@@ -12205,17 +12247,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 +12509,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 +12603,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 +12631,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 {
@@ -12981,7 +13019,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(!parentNode.isWildcardImport);
             const importInfo = AnalyzerNodeInfo.getImportInfo(parentNode.module);
             if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
-                const resolvedPath = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
+                const resolvedPath = importInfo.resolvedUris[importInfo.resolvedUris.length - 1];
                 const importLookupInfo = importLookup(resolvedPath);
                 let reportError = false;
                 // If we were able to resolve the import, report the error as
@@ -13001,7 +13039,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                else if (!resolvedPath) {
+                else if (resolvedPath.isEmpty()) {
                     // This corresponds to the "from . import a" form.
                     reportError = true;
                 }
@@ -13765,7 +13803,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) };
@@ -14404,13 +14442,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (namePartIndex >= 0 &&
                 importInfo &&
                 !importInfo.isNativeLib &&
-                namePartIndex < importInfo.resolvedPaths.length) {
-                if (importInfo.resolvedPaths[namePartIndex]) {
+                namePartIndex < importInfo.resolvedUris.length) {
+                if (importInfo.resolvedUris[namePartIndex]) {
                     evaluateTypesForStatement(node);
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedPaths[namePartIndex]));
+                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -14723,8 +14761,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
         }
         function applyLoaderActionsToModuleType(moduleType, loaderActions, importLookup) {
-            if (loaderActions.path && loaderActions.loadSymbolsFromPath) {
-                const lookupResults = importLookup(loaderActions.path);
+            if (!loaderActions.uri.isEmpty() && loaderActions.loadSymbolsFromPath) {
+                const lookupResults = importLookup(loaderActions.uri);
                 if (lookupResults) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
@@ -14747,7 +14785,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else {
                         const moduleName = moduleType.moduleName ? moduleType.moduleName + '.' + name : '';
-                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.path);
+                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
                         symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup);
                     }
                     const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
@@ -14762,7 +14800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (resolvedDecl.type === 8 /* DeclarationType.Alias */) {
             // Build a module type that corresponds to the declaration and
             // its associated loader actions.
-            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.path);
+            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
             if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
                 return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
             }
@@ -14856,7 +14894,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // (but not an ellipsis).
                 if (isLegalImplicitTypeAliasType(inferredType)) {
                     inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
-                    /* isPep695Syntax */ false);
+                    /* isPep695Syntax */ false, 
+                    /* isPep695TypeVarType */ false);
                     isUnambiguousType = true;
                 }
             }
@@ -15760,11 +15799,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // the length of the src type arguments list if the dest or source contain
     // entries with indeterminate length or variadic entries. It returns true
     // if the source is potentially compatible with the dest type, false otherwise.
-    function adjustSrcTupleTypeArgs(destTypeArgs, srcTypeArgs) {
-        const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
+    function adjustTupleTypeArgs(destTypeArgs, srcTypeArgs, flags) {
+        const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
+        const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
         // If the src contains an unbounded type but the dest does not, it's incompatible.
-        if (srcUnboundedIndex >= 0 && destUnboundedIndex < 0) {
+        if (srcUnboundedIndex >= 0 && destUnboundedOrVariadicIndex < 0) {
             return false;
         }
         if (srcUnboundedIndex >= 0) {
@@ -15775,36 +15815,71 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
             }
         }
-        const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
-        if (destUnboundedIndex >= 0 && srcArgsToCapture >= 0) {
-            // If the dest contains a variadic element, determine which source
-            // args map to this element and package them up into an unpacked tuple.
-            if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedIndex].type)) {
-                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    const removedArgs = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture);
+        // 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);
+        }
+        if (srcVariadicIndex >= 0) {
+            const destArgsToCapture = destTypeArgs.length - srcTypeArgs.length + 1;
+            // If we're doing reverse type mappings and the source contains a variadic
+            // TypeVar, we need to adjust the dest so the reverse type mapping assignment
+            // can be performed.
+            if (destArgsToCapture >= 0 && (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
+                // If the only removed arg from the dest type args is itself a variadic,
+                // don't bother adjusting it.
+                const skipAdjustment = destArgsToCapture === 1 && (0, types_1.isVariadicTypeVar)(destTypeArgs[srcVariadicIndex].type);
+                if (!skipAdjustment && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    const removedArgs = destTypeArgs.splice(srcVariadicIndex, destArgsToCapture);
                     // Package up the remaining type arguments into a tuple object.
                     const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
                         return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
                     }), 
                     /* isTypeArgumentExplicit */ true, 
                     /* isUnpackedTuple */ true));
-                    srcTypeArgs.splice(destUnboundedIndex, 0, {
+                    destTypeArgs.splice(srcVariadicIndex, 0, {
                         type: variadicTuple,
                         isUnbounded: false,
                     });
                 }
             }
-            else {
-                const removedArgTypes = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture).map((t) => {
-                    if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
-                        return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+        }
+        else {
+            const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
+            if (destUnboundedOrVariadicIndex >= 0 && srcArgsToCapture >= 0) {
+                // If the dest contains a variadic element, determine which source
+                // args map to this element and package them up into an unpacked tuple.
+                if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
+                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                        const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
+                        // Package up the remaining type arguments into a tuple object.
+                        const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
+                            return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                        }), 
+                        /* isTypeArgumentExplicit */ true, 
+                        /* isUnpackedTuple */ true));
+                        srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                            type: variadicTuple,
+                            isUnbounded: false,
+                        });
                     }
-                    return t.type;
-                });
-                srcTypeArgs.splice(destUnboundedIndex, 0, {
-                    type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                    isUnbounded: false,
-                });
+                }
+                else {
+                    const removedArgTypes = srcTypeArgs
+                        .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
+                        .map((t) => {
+                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
+                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                        }
+                        return t.type;
+                    });
+                    srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                        isUnbounded: false,
+                    });
+                }
             }
         }
         return destTypeArgs.length === srcTypeArgs.length;
@@ -15813,8 +15888,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
-        const reverseMapping = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
-        if (adjustSrcTupleTypeArgs(reverseMapping ? srcTypeArgs : destTypeArgs, reverseMapping ? destTypeArgs : srcTypeArgs)) {
+        if (adjustTupleTypeArgs(destTypeArgs, srcTypeArgs, flags)) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -16014,6 +16088,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 else if (types_1.ClassType.isBuiltIn(destType, 'list')) {
                                     childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionList());
                                 }
+                                else if (types_1.ClassType.isBuiltIn(destType, 'set')) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionSet());
+                                }
                             }
                         }
                         else {
@@ -16313,14 +16390,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)));
@@ -16332,7 +16407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // PEP 544 says that if the dest type is a type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
                 if (types_1.ClassType.isProtocolClass(destType) &&
-                    (flags & 4096 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
+                    (flags & 8192 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
@@ -17020,15 +17095,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 +17155,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 +18184,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;
                     }
@@ -18252,7 +18319,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!assignType(memberTypeFirstParamType, firstParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), typeVarContext, 
-            /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
+            /* srcTypeVarContext */ undefined, 4096 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {