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

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);
                     }
@@ -621,6 +622,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
+                if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                    addError(localize_1.Localizer.Diagnostic.walrusNotAllowed(), node);
+                }
                 typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext);
                 assignTypeToExpression(node.name, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true);
@@ -760,6 +764,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
+        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            addError(localize_1.Localizer.Diagnostic.awaitNotAllowed(), node);
+            return { type: types_1.UnknownType.create() };
+        }
         const effectiveExpectedType = inferenceContext
             ? createAwaitableReturnType(node, inferenceContext.expectedType, 
             /* isGenerator */ false, 
@@ -814,24 +822,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !iterType.isVariadicUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
+        else if ((flags & 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */) !== 0 &&
+            (0, types_1.isInstantiableClass)(iterType) &&
+            types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
+            typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
+        }
+        else if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            addError(localize_1.Localizer.Diagnostic.unpackInAnnotation(), node, node.starToken);
+            typeResult = { type: types_1.UnknownType.create() };
+        }
         else {
-            if ((flags & 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */) !== 0 &&
-                (0, types_1.isInstantiableClass)(iterType) &&
-                types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
-                typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
-            }
-            else {
-                const iteratorTypeResult = (_a = getTypeOfIterator(iterTypeResult, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : {
-                    type: types_1.UnknownType.create(!!iterTypeResult.isIncomplete),
-                    isIncomplete: iterTypeResult.isIncomplete,
-                };
-                typeResult = {
-                    type: iteratorTypeResult.type,
-                    typeErrors: iterTypeResult.typeErrors,
-                    unpackedType: iterType,
-                    isIncomplete: iteratorTypeResult.isIncomplete,
-                };
-            }
+            const iteratorTypeResult = (_a = getTypeOfIterator(iterTypeResult, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : {
+                type: types_1.UnknownType.create(!!iterTypeResult.isIncomplete),
+                isIncomplete: iterTypeResult.isIncomplete,
+            };
+            typeResult = {
+                type: iteratorTypeResult.type,
+                typeErrors: iterTypeResult.typeErrors,
+                unpackedType: iterType,
+                isIncomplete: iteratorTypeResult.isIncomplete,
+            };
         }
         return typeResult;
     }
@@ -1407,9 +1417,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;
     }
@@ -1492,8 +1500,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // type information than `__new__`.
                         const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 
                         /* skipObjectBase */ false);
-                        if (initMethodResult && !initMethodResult.typeErrors && (0, types_1.isFunction)(initMethodResult.type)) {
-                            constructorType = initMethodResult.type;
+                        if (initMethodResult && !initMethodResult.typeErrors) {
+                            if ((0, types_1.isFunction)(initMethodResult.type) || (0, types_1.isOverloadedFunction)(initMethodResult.type)) {
+                                constructorType = initMethodResult.type;
+                            }
                         }
                         const isObjectInit = constructorType &&
                             (0, types_1.isFunction)(constructorType) &&
@@ -1507,11 +1517,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (!constructorType || isObjectInit || isDefaultParams) {
                             const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 
                             /* skipObjectBase */ false);
-                            if (newMethodResult &&
-                                !newMethodResult.typeErrors &&
-                                (0, types_1.isFunction)(newMethodResult.type) &&
-                                newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
-                                constructorType = newMethodResult.type;
+                            if (newMethodResult && !newMethodResult.typeErrors && (0, types_1.isFunction)(newMethodResult.type)) {
+                                if ((0, types_1.isFunction)(newMethodResult.type) &&
+                                    newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
+                                    constructorType = newMethodResult.type;
+                                }
+                                else if ((0, types_1.isOverloadedFunction)(newMethodResult.type)) {
+                                    constructorType = newMethodResult.type;
+                                }
                             }
                         }
                         if (constructorType) {
@@ -1923,7 +1936,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;
         }
@@ -2473,9 +2486,7 @@ 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 ((0, types_1.isTypeVar)(subtype) && subtype.details.isVariadic) {
                 // If it's in a union, convert to type or object.
@@ -3072,7 +3083,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.
@@ -3092,16 +3103,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
@@ -3288,7 +3296,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     name: type.typeAliasInfo.name,
                 }), node);
             }
-            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
+            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
         }
         return type;
     }
@@ -3624,9 +3632,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)) {
@@ -4642,7 +4648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             aliasTypeArgs.push(typeVarType);
         });
-        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.isPep695Syntax, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
+        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.moduleName, baseType.typeAliasInfo.fileUri, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.isPep695Syntax, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
         return { type, node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
@@ -4653,7 +4659,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, !!baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', '', uri_1.Uri.empty(), baseTypeResult.type.details.recursiveTypeAliasScopeId, !!baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
@@ -5706,9 +5712,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 +5775,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 +5843,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 +6231,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,9 +6711,10 @@ 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;
+            newClassType.details.declaration = returnType.details.declaration;
             (0, typeUtils_1.computeMroLinearization)(newClassType);
             returnType = newClassType;
         }
@@ -6824,7 +6873,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if (typeResult.type.details.paramSpec) {
             const paramSpecScopeId = typeResult.type.details.paramSpec.scopeId;
-            if (paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
+            if (typeResult.type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId ||
+                paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
                 paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
                 hasParamSpecArgsKwargs = true;
                 paramSpecArgList = [];
@@ -7611,7 +7661,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 */;
         }
@@ -7623,7 +7673,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;
@@ -7669,6 +7719,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
                             unknownIfNotFound: true,
                         });
+                        effectiveFlags |= 2048 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
                     }
                 }
             }
@@ -7684,7 +7735,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);
     }
@@ -8101,7 +8152,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let argErrorNode;
             for (const arg of argList) {
                 const argType = (_a = getTypeOfArgument(arg)) === null || _a === void 0 ? void 0 : _a.type;
-                const isArgTypeCompatible = argType && ((0, types_1.isTypeSame)(argType, paramSpec) || (0, types_1.isAnyOrUnknown)(argType));
+                const isArgTypeCompatible = argType && ((0, types_1.isTypeSame)(argType, paramSpec, { ignoreTypeFlags: true }) || (0, types_1.isAnyOrUnknown)(argType));
                 if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */ && !sawArgs && isArgTypeCompatible) {
                     sawArgs = true;
                 }
@@ -8751,7 +8802,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 */) {
@@ -8819,7 +8870,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);
@@ -8866,7 +8917,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);
@@ -10656,7 +10707,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;
         }
@@ -10701,27 +10752,32 @@ 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 typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
+        const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), fileInfo.moduleName, fileInfo.fileUri, 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) {
+        var _a;
         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);
+        const specialBuiltInClassDeclaration = ((_a = AnalyzerNodeInfo.getDeclaration(node)) !== null && _a !== void 0 ? _a : (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
+        specialClassType.details.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
             specialClassType.details.flags |= 65536 /* ClassTypeFlags.TypingExtensionClass */;
         }
@@ -10967,7 +11023,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({
@@ -11024,11 +11081,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
@@ -11067,7 +11123,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,
@@ -11128,7 +11185,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));
@@ -11150,6 +11207,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
         classType.details.flags |= 131072 /* ClassTypeFlags.PartiallyEvaluated */;
+        classType.details.declaration = classDecl;
         try {
             writeTypeCache(node, { type: classType }, /* flags */ undefined);
             writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
@@ -11669,7 +11727,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) {
@@ -11952,7 +12010,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);
                         }
                     }
                 }
@@ -12747,7 +12805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // This eliminates any "partially unknown" errors in strict mode
                             // in the common case.
                             const sendType = isYieldResultUsed ? types_1.UnknownType.create() : types_1.AnyType.create();
-                            typeArgs.push(inferredYieldType, sendType, (0, types_1.isNever)(inferredReturnType) ? getNoneType() : inferredReturnType);
+                            typeArgs.push(inferredYieldType, sendType, inferredReturnType);
                             if (useAwaitableGenerator) {
                                 typeArgs.push(types_1.AnyType.create());
                             }
@@ -12981,7 +13039,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 +13059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                else if (!resolvedPath) {
+                else if (resolvedPath.isEmpty()) {
                     // This corresponds to the "from . import a" form.
                     reportError = true;
                 }
@@ -14404,13 +14462,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 +14781,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 +14805,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 +14820,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 +14914,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;
                 }
             }
@@ -15304,7 +15363,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let returnType;
         let isIncomplete = false;
-        let analyzeUnannotatedFunctions = true;
+        const analyzeUnannotatedFunctions = true;
         // Don't attempt to infer the return type for a stub file.
         if (types_1.FunctionType.isStubDefinition(type)) {
             return types_1.UnknownType.create();
@@ -15327,10 +15386,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (type.details.declaration) {
                 const functionNode = type.details.declaration.node;
-                analyzeUnannotatedFunctions =
-                    AnalyzerNodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions;
+                const skipUnannotatedFunction = !AnalyzerNodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions &&
+                    ParseTreeUtils.isUnannotatedFunction(functionNode);
                 // Skip return type inference if we are in "skip unannotated function" mode.
-                if (analyzeUnannotatedFunctions && !checkCodeFlowTooComplex(functionNode.suite)) {
+                if (!skipUnannotatedFunction && !checkCodeFlowTooComplex(functionNode.suite)) {
                     const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
                     // For very complex functions that have no annotated parameter types,
                     // don't attempt to infer the return type because it can be extremely
@@ -15760,11 +15819,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) {
@@ -15782,36 +15842,64 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         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
-            // 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);
+        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;
@@ -15820,8 +15908,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)) {
@@ -16021,6 +16108,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 {
@@ -16337,7 +16427,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) {
@@ -16621,7 +16711,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let canUseFastPath = true;
             // First attempt to match all of the non-generic types in the dest
             // to non-generic types in the source.
-            destType.subtypes.forEach((destSubtype) => {
+            (0, typeUtils_1.sortTypes)(destType.subtypes).forEach((destSubtype) => {
                 if ((0, typeUtils_1.requiresSpecialization)(destSubtype)) {
                     remainingDestSubtypes.push(destSubtype);
                 }
@@ -17129,7 +17219,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
         const checkReturnType = (flags & 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
@@ -17140,19 +17230,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const srcParamDetails = (0, parameterUtils_1.getParameterListDetails)(srcType);
         adjustSourceParamDetailsForDestVariadic(reverseMatching ? destParamDetails : srcParamDetails, reverseMatching ? srcParamDetails : destParamDetails);
         const targetIncludesParamSpec = reverseMatching ? !!srcType.details.paramSpec : !!destType.details.paramSpec;
-        const destPositionalCount = (_b = (_a = destParamDetails.argsIndex) !== null && _a !== void 0 ? _a : destParamDetails.firstKeywordOnlyIndex) !== null && _b !== void 0 ? _b : destParamDetails.params.length;
-        const srcPositionalCount = (_d = (_c = srcParamDetails.argsIndex) !== null && _c !== void 0 ? _c : srcParamDetails.firstKeywordOnlyIndex) !== null && _d !== void 0 ? _d : srcParamDetails.params.length;
+        const destPositionalCount = (_a = destParamDetails.firstKeywordOnlyIndex) !== null && _a !== void 0 ? _a : destParamDetails.params.length;
+        const srcPositionalCount = (_b = srcParamDetails.firstKeywordOnlyIndex) !== null && _b !== void 0 ? _b : srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
         // Match positional parameters.
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
+            // Skip over the *args parameter since it's handled separately below.
+            if (paramIndex === destParamDetails.argsIndex) {
+                continue;
+            }
             const destParam = destParamDetails.params[paramIndex];
             const srcParam = srcParamDetails.params[paramIndex];
             // Find the original index of this source param. If we synthesized it above (for
             // a variadic parameter), it may not be found.
             const srcParamType = srcParam.type;
             const destParamType = destParam.type;
-            const destParamName = (_e = destParam.param.name) !== null && _e !== void 0 ? _e : '';
-            const srcParamName = (_f = srcParam.param.name) !== null && _f !== void 0 ? _f : '';
+            const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
+            const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
             if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
                 const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
@@ -17166,7 +17260,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     canAssign = false;
                 }
             }
-            if (!!destParam.param.hasDefault && !srcParam.param.hasDefault) {
+            if (!!destParam.param.hasDefault &&
+                !srcParam.param.hasDefault &&
+                paramIndex !== srcParamDetails.argsIndex) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamDefaultMissing().format({
                     name: srcParamName,
                 }));
@@ -17240,6 +17336,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // *args parameter type.
                 const srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
                 for (let paramIndex = srcPositionalCount; paramIndex < destPositionalCount; paramIndex++) {
+                    if (paramIndex === srcParamDetails.argsIndex) {
+                        continue;
+                    }
                     const destParamType = destParamDetails.params[paramIndex].type;
                     if ((0, types_1.isVariadicTypeVar)(destParamType) && !(0, types_1.isVariadicTypeVar)(srcArgsType)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarTupleRequiresKnownLength());
@@ -17252,7 +17351,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (destParamDetails.params[paramIndex].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInSource().format({
-                                name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : '',
+                                name: (_e = destParamDetails.params[paramIndex].param.name) !== null && _e !== void 0 ? _e : '',
                             }));
                             canAssign = false;
                         }
@@ -17260,11 +17359,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!srcParamDetails.paramSpec) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionTooManyParams().format({
-                    expected: srcPositionalCount,
-                    received: destPositionalCount,
-                }));
-                canAssign = false;
+                // If the dest contains a *args, remove it from the positional count
+                // because it's OK for zero source args to match it.
+                let adjDestPositionalCount = destPositionalCount;
+                if (destParamDetails.argsIndex !== undefined && destParamDetails.argsIndex < destPositionalCount) {
+                    adjDestPositionalCount--;
+                }
+                if (srcPositionalCount < adjDestPositionalCount) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionTooManyParams().format({
+                        expected: srcPositionalCount,
+                        received: destPositionalCount,
+                    }));
+                    canAssign = false;
+                }
             }
         }
         // If both src and dest have an "*args" parameter, make sure
@@ -17296,7 +17403,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destParamDetails.argsIndex !== undefined &&
             !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsParamMissing().format({
-                paramName: (_h = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _h !== void 0 ? _h : '',
+                paramName: (_f = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _f !== void 0 ? _f : '',
             }));
             canAssign = false;
         }
@@ -17407,7 +17514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the source and the dest are using the same ParamSpec, any additional
         // concatenated parameters must match.
         if (targetIncludesParamSpec &&
-            ((_j = srcType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope) === ((_k = destType.details.paramSpec) === null || _k === void 0 ? void 0 : _k.nameWithScope)) {
+            ((_g = srcType.details.paramSpec) === null || _g === void 0 ? void 0 : _g.nameWithScope) === ((_h = destType.details.paramSpec) === null || _h === void 0 ? void 0 : _h.nameWithScope)) {
             if (srcParamDetails.params.length !== destParamDetails.params.length) {
                 canAssign = false;
             }
@@ -18249,7 +18356,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) {