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

package/dist/analyzer/typeEvaluator.js

@@ -568,7 +568,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 55 /* ParseNodeType.UnaryOperation */: {
-                typeResult = (0, operations_1.getTypeOfUnaryOperation)(evaluatorInterface, node, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfUnaryOperation)(evaluatorInterface, node, flags, inferenceContext);
                 break;
             }
             case 7 /* ParseNodeType.BinaryOperation */: {
@@ -622,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);
@@ -761,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, 
@@ -815,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;
     }
@@ -1324,7 +1333,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
             !types_1.ClassType.isSameGenericClass(metaclass, objectType)) {
             const descMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, memberName, usage, 
-            /* diag */ undefined, flags | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, objectType);
+            /* diag */ undefined, flags | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, objectType, recursionCount);
             if (descMemberInfo) {
                 const isProperty = (0, types_1.isClassInstance)(descMemberInfo.type) && types_1.ClassType.isPropertyClass(descMemberInfo.type);
                 if ((0, typeUtils_1.isDescriptorInstance)(descMemberInfo.type, /* requireSetter */ true) || isProperty) {
@@ -1344,7 +1353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
             // See if the member is present in the object itself.
-            memberInfo = getTypeOfClassMemberName(errorNode, objectType, memberName, usage, subDiag, effectiveFlags, selfType);
+            memberInfo = getTypeOfClassMemberName(errorNode, objectType, memberName, usage, subDiag, effectiveFlags, selfType, recursionCount);
         }
         // If it wasn't found on the object, see if it's part of the metaclass.
         if (!memberInfo && metaclass && (0, types_1.isInstantiableClass)(metaclass)) {
@@ -1491,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) &&
@@ -1506,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) {
@@ -2336,7 +2350,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Is this subtype a tuple?
             const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
             if (tupleType && tupleType.tupleTypeArguments) {
-                const sourceEntryTypes = tupleType.tupleTypeArguments.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype)));
+                const sourceEntryTypes = tupleType.tupleTypeArguments.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), /* skipSelfCondition */ true));
                 const unboundedIndex = tupleType.tupleTypeArguments.findIndex((t) => t.isUnbounded);
                 if (unboundedIndex >= 0) {
                     if (sourceEntryTypes.length < targetTypes.length) {
@@ -2489,7 +2503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return subtype;
             }
-            if ((0, types_1.isTypeVar)(subtype) && !subtype.details.recursiveTypeAliasName) {
+            if ((0, types_1.isTypeVar)(subtype)) {
                 // If this is a recursive type alias placeholder
                 // that hasn't yet been resolved, return it as is.
                 if (subtype.details.recursiveTypeAliasName) {
@@ -2502,7 +2516,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     subtype.details.constraints.forEach((constraintType, constraintIndex) => {
                         if (conditionFilter) {
                             const typeVarName = types_1.TypeVarType.getNameWithScope(subtype);
-                            const applicableConstraint = conditionFilter.find((filter) => filter.typeVarName === typeVarName);
+                            const applicableConstraint = conditionFilter.find((filter) => filter.typeVar.nameWithScope === typeVarName);
                             // If this type variable is being constrained to a single index,
                             // don't include the other indices.
                             if (applicableConstraint && applicableConstraint.constraintIndex !== constraintIndex) {
@@ -2512,13 +2526,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (types_1.TypeBase.isInstantiable(subtype)) {
                             constraintType = (0, typeUtils_1.convertToInstantiable)(constraintType);
                         }
-                        typesToCombine.push((0, typeUtils_1.addConditionToType)(constraintType, [
-                            {
-                                typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                                constraintIndex,
-                                isConstrainedTypeVar: true,
-                            },
-                        ]));
+                        typesToCombine.push((0, typeUtils_1.addConditionToType)(constraintType, [{ typeVar: subtype, constraintIndex }]));
                     });
                     return (0, types_1.combineTypes)(typesToCombine);
                 }
@@ -2528,17 +2536,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Fall back to a bound of "object" if no bound is provided.
                 let boundType = (_b = (_a = subtype.details.boundType) !== null && _a !== void 0 ? _a : objectType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
-                // Handle Self and type[Self] specially.
-                if (subtype.details.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
-                    return types_1.ClassType.cloneIncludeSubclasses(boundType);
-                }
-                return (0, typeUtils_1.addConditionToType)(boundType, [
-                    {
-                        typeVarName: types_1.TypeVarType.getNameWithScope(subtype),
-                        constraintIndex: 0,
-                        isConstrainedTypeVar: false,
-                    },
-                ]);
+                return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
             return subtype;
         });
@@ -2570,7 +2568,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (transformedType) {
                     // Apply the type condition if it's associated with a constrained TypeVar.
-                    const typeCondition = (_a = (0, typeUtils_1.getTypeCondition)(subtype)) === null || _a === void 0 ? void 0 : _a.filter((condition) => condition.isConstrainedTypeVar);
+                    const typeCondition = (_a = (0, typeUtils_1.getTypeCondition)(subtype)) === null || _a === void 0 ? void 0 : _a.filter((condition) => condition.typeVar.details.constraints.length > 0);
                     if (typeCondition && typeCondition.length > 0) {
                         transformedType = (0, typeUtils_1.addConditionToType)(transformedType, typeCondition);
                     }
@@ -3282,7 +3280,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;
     }
@@ -3568,7 +3566,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeResult = (_a = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete)) !== null && _a !== void 0 ? _a : getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                 /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 if (typeResult) {
-                    type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
+                    type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
+                    /* skipSelfCondition */ true);
                 }
                 if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
                     isIncomplete = true;
@@ -4634,7 +4633,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) {
@@ -4645,7 +4644,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;
@@ -6700,6 +6699,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             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;
         }
@@ -6858,7 +6858,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 = [];
@@ -7963,11 +7964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         !arg0Type.details.isParamSpec &&
                         arg0Type.details.constraints.length === 0) {
                         typeGuardType = (0, typeUtils_1.addConditionToType)(typeGuardType, [
-                            {
-                                typeVarName: types_1.TypeVarType.getNameWithScope(arg0Type),
-                                constraintIndex: 0,
-                                isConstrainedTypeVar: false,
-                            },
+                            { typeVar: arg0Type, constraintIndex: 0 },
                         ]);
                     }
                 }
@@ -8136,7 +8133,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;
                 }
@@ -10745,7 +10742,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         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);
+        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 || isPep695TypeVarType) {
@@ -10754,11 +10751,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         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.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 */;
         }
@@ -11188,6 +11188,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);
@@ -12785,7 +12786,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());
                             }
@@ -14989,30 +14990,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Returns the type of the symbol. If the type is explicitly declared, that type
     // is returned. If not, the type is inferred from assignments to the symbol. All
-    // assigned types are evaluated and combined into a union. If a "usageNode"
-    // node is specified, only declarations that are outside of the current execution
-    // scope or that are reachable (as determined by code flow analysis) are considered.
-    // This helps in cases where there are cyclical dependencies between symbols.
+    // assigned types are evaluated and combined into a union.
     function getEffectiveTypeOfSymbol(symbol) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
+    // If a "usageNode" node is specified, only declarations that are outside
+    // of the current execution scope or that are reachable (as determined by
+    // code flow analysis) are considered. This helps in cases where there
+    // are cyclical dependencies between symbols.
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             declaredTypeInfo = getDeclaredTypeOfSymbol(symbol, usageNode);
             const declaredType = declaredTypeInfo === null || declaredTypeInfo === void 0 ? void 0 : declaredTypeInfo.type;
-            const hasMetadata = !!declaredTypeInfo.isTypeAlias;
-            if (declaredType || !hasMetadata) {
-                let isIncomplete = false;
-                if (declaredType) {
-                    if ((0, types_1.isFunction)(declaredType) && types_1.FunctionType.isPartiallyEvaluated(declaredType)) {
-                        isIncomplete = true;
-                    }
-                    else if ((0, types_1.isClass)(declaredType) && types_1.ClassType.isPartiallyEvaluated(declaredType)) {
-                        isIncomplete = true;
-                    }
+            let isIncomplete = false;
+            if (declaredType) {
+                if ((0, types_1.isFunction)(declaredType) && types_1.FunctionType.isPartiallyEvaluated(declaredType)) {
+                    isIncomplete = true;
+                }
+                else if ((0, types_1.isClass)(declaredType) && types_1.ClassType.isPartiallyEvaluated(declaredType)) {
+                    isIncomplete = true;
                 }
+            }
+            // If the "declared" type uses a "TypeAlias" type annotation, then
+            // we need to use the inferred type path to evaluate its type.
+            if (declaredType || !declaredTypeInfo.isTypeAlias) {
                 const typedDecls = symbol.getTypedDeclarations();
                 const result = {
                     type: declaredType !== null && declaredType !== void 0 ? declaredType : types_1.UnknownType.create(),
@@ -15025,6 +15028,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return result;
             }
         }
+        return inferTypeOfSymbolForUsage(symbol, usageNode, useLastDecl);
+    }
+    function inferTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
         // Look in the inferred type cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
         const usageNodeId = usageNode ? usageNode.id : undefined;
@@ -15072,9 +15078,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Determine which declarations to use for inference.
         const declsToConsider = [];
+        let includesVariableDecl = false;
+        let includesIllegalTypeAliasDecl = false;
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
             var _a, _b, _c;
+            const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+                allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+            })) !== null && _a !== void 0 ? _a : decl;
+            if (!isPossibleTypeAliasDeclaration(resolvedDecl)) {
+                includesIllegalTypeAliasDecl = true;
+            }
+            if (resolvedDecl.type === 1 /* DeclarationType.Variable */) {
+                // Exempt typing.pyi, which uses variables to define some
+                // special forms like Any.
+                const fileInfo = AnalyzerNodeInfo.getFileInfo(resolvedDecl.node);
+                if (!fileInfo.isTypingStubFile) {
+                    includesVariableDecl = true;
+                }
+            }
             if (declIndexToConsider !== undefined && declIndexToConsider !== index) {
                 return;
             }
@@ -15094,18 +15116,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (usageNode !== undefined) {
                 if (decl.type !== 8 /* DeclarationType.Alias */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
+                    // If so, we can skip it because code flow analysis will allow us
+                    // to determine the type in this context.
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
                     const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
                     if (usageScope === declScope) {
-                        if (!isFlowPathBetweenNodes(decl.node, usageNode)) {
-                            return;
-                        }
+                        return;
                     }
                 }
             }
-            const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
-                allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
-            })) !== null && _a !== void 0 ? _a : decl;
             const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
             const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
             if (isExplicitTypeAlias) {
@@ -15121,6 +15140,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             declsToConsider.push(resolvedDecl);
         });
         const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
+        result.includesVariableDecl = includesVariableDecl;
+        result.includesIllegalTypeAliasDecl = includesIllegalTypeAliasDecl;
         // Add the result to the effective type cache if it doesn't include speculative results.
         if (!result.includesSpeculativeResult) {
             addToEffectiveTypeCache(result);
@@ -15141,7 +15162,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typesToCombine = [];
         let isIncomplete = false;
         let sawPendingEvaluation = false;
-        let includesVariableDecl = false;
         let includesSpeculativeResult = false;
         decls.forEach((decl) => {
             if (pushSymbolResolution(symbol, decl)) {
@@ -15152,12 +15172,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (type) {
                         if (decl.type === 1 /* DeclarationType.Variable */) {
-                            // Exempt typing.pyi, which uses variables to define some
-                            // special forms like Any.
-                            const fileInfo = AnalyzerNodeInfo.getFileInfo(decl.node);
-                            if (!fileInfo.isTypingStubFile) {
-                                includesVariableDecl = true;
-                            }
                             let isConstant = false;
                             if (decl.type === 1 /* DeclarationType.Variable */) {
                                 if (decl.isConstant || isFinalVariableDeclaration(decl)) {
@@ -15219,15 +15233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             type = types_1.UnboundType.create();
         }
-        return {
-            type,
-            isIncomplete,
-            includesVariableDecl,
-            includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
-            includesSpeculativeResult,
-            isRecursiveDefinition: false,
-            evaluationAttempts,
-        };
+        return { type, isIncomplete, includesSpeculativeResult, evaluationAttempts };
     }
     // If a declaration has an explicit type (e.g. a variable with an annotation),
     // this function evaluates the type and returns it. If the symbol has no
@@ -15343,7 +15349,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();
@@ -15366,10 +15372,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
@@ -16208,7 +16214,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (types_1.TypeBase.isInstantiable(destType) === types_1.TypeBase.isInstantiable(srcType) &&
                 srcType.condition &&
                 srcType.condition.some((cond) => {
-                    return !cond.isConstrainedTypeVar && cond.typeVarName === destTypeVar.nameWithScope;
+                    return (cond.typeVar.details.constraints.length === 0 &&
+                        cond.typeVar.nameWithScope === destTypeVar.nameWithScope);
                 })) {
                 return true;
             }
@@ -16691,7 +16698,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);
                 }
@@ -16999,13 +17006,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const destTypeVarName = types_1.TypeVarType.getNameWithScope(destType);
             // Determine which conditions on this type apply to this type variable.
             // There might be more than one of them.
-            const applicableConditions = ((_a = (0, typeUtils_1.getTypeCondition)(srcSubtype)) !== null && _a !== void 0 ? _a : []).filter((constraint) => constraint.typeVarName === destTypeVarName);
+            const applicableConditions = ((_a = (0, typeUtils_1.getTypeCondition)(srcSubtype)) !== null && _a !== void 0 ? _a : []).filter((constraint) => constraint.typeVar.nameWithScope === destTypeVarName);
             // If there are no applicable conditions, it's not assignable.
             if (applicableConditions.length === 0) {
                 return true;
             }
             return !applicableConditions.some((condition) => {
-                if (condition.typeVarName === types_1.TypeVarType.getNameWithScope(destType)) {
+                if (condition.typeVar.nameWithScope === types_1.TypeVarType.getNameWithScope(destType)) {
                     if (destType.details.boundType) {
                         (0, debug_1.assert)(condition.constraintIndex === 0, 'Expected constraint for bound TypeVar to have index of 0');
                         return assignType(destType.details.boundType, srcSubtype, 
@@ -17199,7 +17206,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;
@@ -17210,19 +17217,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 &&
@@ -17236,7 +17247,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,
                 }));
@@ -17310,6 +17323,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());
@@ -17322,7 +17338,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;
                         }
@@ -17330,11 +17346,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
@@ -17366,7 +17390,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;
         }
@@ -17477,7 +17501,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;
             }