@zzzen/pyright-internal 1.2.0-dev.20230226 → 1.2.0-dev.20230312

package/dist/analyzer/typeEvaluator.js

@@ -253,6 +253,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let strClassType;
     let dictClassType;
     let typedDictClassType;
+    let typedDictPrivateClassType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
@@ -500,7 +501,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             intClassType = getBuiltInType(node, 'int');
             strClassType = getBuiltInType(node, 'str');
             dictClassType = getBuiltInType(node, 'dict');
-            typedDictClassType = getTypingType(node, '_TypedDict');
+            typedDictClassType = getTypingType(node, 'TypedDict');
+            typedDictPrivateClassType = getTypingType(node, '_TypedDict');
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
@@ -1000,6 +1002,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.notParsedByInterpreter) {
             evaluatorFlags |= 524288 /* NotParsedByInterpreter */;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowRequired) {
+            evaluatorFlags |= 1048576 /* AllowRequired */;
+        }
         if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo)) {
             evaluatorFlags |= 4 /* AllowForwardReferences */;
         }
@@ -1496,7 +1501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* honorCodeFlow */ false);
                 if (symbolWithScope) {
                     const symbol = symbolWithScope.symbol;
-                    return symbol.getDeclarations().find((decl) => (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl)) !== undefined;
+                    return symbol.getDeclarations().find((decl) => isExplicitTypeAliasDeclaration(decl)) !== undefined;
                 }
             }
         }
@@ -1504,6 +1509,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Determines whether the specified expression is a symbol with a declared type.
     function getDeclaredTypeForExpression(expression, usage) {
+        var _a, _b;
         let symbol;
         let classOrObjectBase;
         let memberAccessClass;
@@ -1516,7 +1522,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Handle the case where the symbol is a class-level variable
                     // where the type isn't declared in this class but is in
                     // a parent class.
-                    if (getDeclaredTypeOfSymbol(symbol, expression) === undefined &&
+                    if (!((_a = getDeclaredTypeOfSymbol(symbol, expression)) === null || _a === void 0 ? void 0 : _a.type) &&
                         symbolWithScope.scope.type === 2 /* Class */) {
                         const enclosingClass = ParseTreeUtils.getEnclosingClassOrFunction(expression);
                         if (enclosingClass && enclosingClass.nodeType === 10 /* Class */) {
@@ -1590,7 +1596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (symbol) {
-            let declaredType = getDeclaredTypeOfSymbol(symbol);
+            let declaredType = (_b = getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
             if (declaredType) {
                 // If it's a descriptor, we need to get the setter type.
                 if ((0, types_1.isClassInstance)(declaredType)) {
@@ -1838,7 +1844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictClassType;
+        return typedDictPrivateClassType;
     }
     function getTupleClassType() {
         return tupleClassType;
@@ -2038,7 +2044,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
     }
     function assignTypeToNameNode(nameNode, type, isTypeIncomplete, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
-        var _a, _b;
+        var _a, _b, _c;
         const nameValue = nameNode.value;
         const symbolWithScope = lookUpSymbolRecursive(nameNode, nameValue, /* honorCodeFlow */ false);
         if (!symbolWithScope) {
@@ -2047,7 +2053,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         const declarations = symbolWithScope.symbol.getDeclarations();
-        let declaredType = getDeclaredTypeOfSymbol(symbolWithScope.symbol);
+        let declaredType = (_a = getDeclaredTypeOfSymbol(symbolWithScope.symbol)) === null || _a === void 0 ? void 0 : _a.type;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
         // If this is a class scope and there is no type declared for this class variable,
         // see if a parent class has a type declared.
@@ -2065,7 +2071,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // We found an existing declared type. Make sure the type is assignable.
         let destType = type;
-        if (declaredType) {
+        const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
+        if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
             if (!assignType(declaredType, type, diagAddendum)) {
                 // If there was an expected type mismatch, use that diagnostic
@@ -2076,7 +2083,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format({
                     sourceType: printType(type),
                     destType: printType(declaredType),
-                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_b = (_a = diagAddendum.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : srcExpression) !== null && _b !== void 0 ? _b : nameNode);
+                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -2094,7 +2101,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((scope === null || scope === void 0 ? void 0 : scope.type) === 2 /* Class */) {
                 if (types_1.TypeBase.isInstance(destType) &&
                     !(0, symbolNameUtils_1.isConstantName)(nameValue) &&
-                    !(0, symbolUtils_1.isFinalVariable)(symbolWithScope.symbol)) {
+                    !isFinalVariable(symbolWithScope.symbol)) {
                     destType = stripLiteralValue(destType);
                 }
             }
@@ -2108,7 +2115,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportConstantRedefinition, diagnosticRules_1.DiagnosticRule.reportConstantRedefinition, localize_1.Localizer.Diagnostic.constantRedefinition().format({ name: nameValue }), nameNode);
                 }
             }
-            else if (varDecl.isFinal && !allowAssignmentToFinalVar) {
+            else if (isFinalVariableDeclaration(varDecl) && !allowAssignmentToFinalVar) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalReassigned().format({ name: nameValue }), nameNode);
             }
         }
@@ -2163,6 +2170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
+        var _a;
         const memberName = node.memberName.value;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const classDef = ParseTreeUtils.getEnclosingClass(node);
@@ -2221,7 +2229,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else {
                     // Is the target a property?
-                    const declaredType = getDeclaredTypeOfSymbol(memberInfo.symbol);
+                    const declaredType = (_a = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _a === void 0 ? void 0 : _a.type;
                     if (declaredType && !(0, typeUtils_1.isProperty)(declaredType)) {
                         // Handle the case where there is a class variable defined with the same
                         // name, but there's also now an instance variable introduced. Combine the
@@ -3120,6 +3128,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // type arguments. If so, it fills in these type arguments with Unknown
     // and optionally reports an error.
     function reportMissingTypeArguments(node, type, flags) {
+        var _a;
         if ((flags & 2 /* DoNotSpecialize */) !== 0) {
             return type;
         }
@@ -3133,7 +3142,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!type.typeArguments) {
-                type = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node);
+                type = (_a = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node)) === null || _a === void 0 ? void 0 : _a.type;
             }
         }
         // Is this a generic type alias that needs to be specialized?
@@ -3351,7 +3360,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a, _b;
+        var _a, _b, _c;
         let baseType = baseTypeResult.type;
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3359,6 +3368,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let type;
         let isIncomplete = !!baseTypeResult.isIncomplete;
         let isAsymmetricDescriptor;
+        const isRequired = false;
+        const isNotRequired = false;
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseTypeResult.type)) {
@@ -3517,7 +3528,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (!type) {
                         if (!isIncomplete) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleUnknownMember().format({ name: memberName }), node.memberName);
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleUnknownMember().format({
+                                memberName,
+                                moduleName: baseType.moduleName,
+                            }), node.memberName);
                         }
                         type = evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
                     }
@@ -3631,7 +3645,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Should we specialize the class?
         if ((flags & 2 /* DoNotSpecialize */) === 0) {
             if ((0, types_1.isInstantiableClass)(type) && !type.typeArguments) {
-                type = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node);
+                type = (_b = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node)) === null || _b === void 0 ? void 0 : _b.type;
             }
         }
         if (usage.method === 'get') {
@@ -3642,7 +3656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // It can also come up in cases like "isinstance(x, (list, dict))".
             if ((0, types_1.isInstantiableClass)(type)) {
                 const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* Argument */);
-                if (argNode && ((_b = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 9 /* Call */) {
+                if (argNode && ((_c = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* Call */) {
                     skipPartialUnknownCheck = true;
                 }
             }
@@ -3651,10 +3665,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* ignoreEmptyContainers */ false);
             }
         }
-        return { type, isIncomplete, isAsymmetricDescriptor };
+        return { type, isIncomplete, isAsymmetricDescriptor, isRequired, isNotRequired };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
-        var _a, _b;
+        var _a, _b, _c;
         let classLookupFlags = 0 /* Default */;
         if (flags & 1 /* AccessClassMembersOnly */) {
             classLookupFlags |= 8 /* SkipInstanceVariables */;
@@ -3695,7 +3709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (containingClassType &&
                         (0, types_1.isInstantiableClass)(containingClassType) &&
                         types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
-                        type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                        type = (_c = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
                         if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
                             type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType);
                         }
@@ -4035,7 +4049,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 // Check for an attempt to overwrite a final member variable.
-                const finalVarTypeDecl = memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.getDeclarations().find((decl) => (0, declarationUtils_1.isFinalVariableDeclaration)(decl));
+                const finalVarTypeDecl = memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.getDeclarations().find((decl) => isFinalVariableDeclaration(decl));
                 if (finalVarTypeDecl && !ParseTreeUtils.isNodeContainedWithin(errorNode, finalVarTypeDecl.node)) {
                     // If a Final instance variable is declared in the class body but is
                     // being assigned within an __init__ method, it's allowed.
@@ -4256,20 +4270,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (baseTypeResult.isIncomplete) {
             indexTypeResult.isIncomplete = true;
         }
-        // Handle "Required" and "NotRequired" specially.
-        if ((flags & 1048576 /* AllowRequired */) !== 0) {
-            if ((0, types_1.isInstantiableClass)(baseTypeResult.type)) {
-                if (types_1.ClassType.isBuiltIn(baseTypeResult.type, 'Required')) {
-                    indexTypeResult.isRequired = true;
-                }
-                else if (types_1.ClassType.isBuiltIn(baseTypeResult.type, 'NotRequired')) {
-                    indexTypeResult.isNotRequired = true;
-                }
-            }
-        }
         return indexTypeResult;
     }
-    function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, typeVarScopeId, errorNode) {
+    function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         // Do we need to adjust the type arguments to map to a variadic type
         // param at the end of the list?
@@ -4341,7 +4344,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Handles index expressions that are providing type arguments for a
     // generic type alias.
     function createSpecializedTypeAlias(node, baseType, flags) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!((_a = baseType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters) ||
             (baseType.typeAliasInfo.typeParameters.length === 0 && baseType.typeAliasInfo.typeArguments)) {
             return undefined;
@@ -4355,7 +4358,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const typeParameters = baseType.typeAliasInfo.typeParameters;
-        let typeArgs = adjustTypeArgumentsForVariadicTypeVar(getTypeArgs(node, flags), typeParameters, baseType.typeAliasInfo.typeVarScopeId, node);
+        let typeArgs = adjustTypeArgumentsForVariadicTypeVar(getTypeArgs(node, flags), typeParameters, node);
         // PEP 612 says that if the class has only one type parameter consisting
         // of a ParamSpec, the list of arguments does not need to be enclosed in
         // a list. We'll handle that case specially here. Presumably this applies to
@@ -4371,13 +4374,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ];
             }
         }
-        if (typeArgs.length > typeParameters.length &&
-            !typeParameters.some((typeVar) => typeVar.details.isVariadic && !typeVar.isVariadicInUnion)) {
-            addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
-                name: printType(baseType),
-                expected: typeParameters.length,
-                received: typeArgs.length,
-            }), typeArgs[typeParameters.length].node);
+        if (!typeParameters.some((typeVar) => typeVar.details.isVariadic && !typeVar.isVariadicInUnion)) {
+            let minTypeArgCount = typeParameters.length;
+            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
+            if (firstNonDefaultParam >= 0) {
+                minTypeArgCount = firstNonDefaultParam;
+            }
+            if (typeArgs.length > typeParameters.length) {
+                addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                    name: printType(baseType),
+                    expected: typeParameters.length,
+                    received: typeArgs.length,
+                }), typeArgs[typeParameters.length].node);
+            }
+            else if (typeArgs.length < minTypeArgCount) {
+                addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
+                    name: printType(baseType),
+                    expected: typeParameters.length,
+                    received: typeArgs.length,
+                }), node.items[node.items.length - 1]);
+            }
         }
         // Handle the mypy_extensions.FlexibleAlias type specially.
         if ((0, types_1.isInstantiableClass)(baseType) &&
@@ -4391,7 +4407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
                 if (typeArgs[index].typeList) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     typeArgs[index].typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
@@ -4437,7 +4453,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
@@ -4460,15 +4476,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     typeArgType = types_1.UnknownType.create();
                 }
+                if ((flags & 16384 /* EnforceTypeVarVarianceConsistency */) !== 0) {
+                    if ((0, types_1.isTypeVar)(typeArgType)) {
+                        const usageVariances = inferTypeParameterVarianceForTypeAlias(baseType);
+                        if (usageVariances && index < usageVariances.length) {
+                            const usageVariance = usageVariances[index];
+                            if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(typeArgType, usageVariance)) {
+                                const messageDiag = diag.createAddendum();
+                                messageDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForTypeAlias().format({
+                                    typeVarName: printType(typeArgType),
+                                    typeAliasParam: printType(typeParameters[index]),
+                                }));
+                                messageDiag.addTextRange(typeArgs[index].node);
+                            }
+                        }
+                    }
+                }
                 (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
             }
         });
         if (!diag.isEmpty()) {
-            addError(localize_1.Localizer.Diagnostic.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node);
+            addError(localize_1.Localizer.Diagnostic.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
         }
         const primarySignatureContext = typeVarContext.getPrimarySignature();
         const aliasTypeArgs = [];
-        (_b = baseType.typeAliasInfo.typeParameters) === null || _b === void 0 ? void 0 : _b.forEach((typeParam) => {
+        (_c = baseType.typeAliasInfo.typeParameters) === null || _c === void 0 ? void 0 : _c.forEach((typeParam) => {
             let typeVarType;
             if ((0, types_1.isParamSpec)(typeParam)) {
                 const paramSpecType = primarySignatureContext.getParamSpecType(typeParam);
@@ -4494,9 +4526,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
+        let isRequired = false;
+        let isNotRequired = false;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
         /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
-            var _a, _b;
+            var _a;
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
                 return concreteSubtype;
             }
@@ -4506,7 +4540,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type: printType(unexpandedSubtype),
                     }), node.baseExpression);
                     // Evaluate the index expressions as though they are type arguments for error-reporting.
-                    getTypeArgs(node, flags, /* isAnnotatedClass */ false, /* hasCustomClassGetItem */ false);
+                    getTypeArgs(node, flags);
                     return types_1.UnknownType.create();
                 }
             }
@@ -4561,9 +4595,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.ClassType.isPartiallyEvaluated(concreteSubtype);
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
-                let typeArgs = getTypeArgs(node, flags, isAnnotatedClass, hasCustomClassGetItem || !isGenericClass, isFinalAnnotation, isClassVarAnnotation);
+                // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
+                const supportsTypedDictTypeArg = (0, types_1.isInstantiableClass)(concreteSubtype) &&
+                    types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
+                    !concreteSubtype.aliasName;
+                let typeArgs = getTypeArgs(node, flags, {
+                    isAnnotatedClass,
+                    hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
+                    isFinalAnnotation,
+                    isClassVarAnnotation,
+                    supportsTypedDictTypeArg,
+                });
                 if (!isAnnotatedClass) {
-                    typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, (_b = (0, typeUtils_1.getTypeVarScopeId)(concreteSubtype)) !== null && _b !== void 0 ? _b : '', node);
+                    typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, node);
                 }
                 // If this is a custom __class_getitem__, there's no need to specialize the class.
                 // Just return it as is.
@@ -4576,7 +4620,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }), node.baseExpression);
                     return concreteSubtype;
                 }
-                return createSpecializedClassType(concreteSubtype, typeArgs, flags, node);
+                const result = createSpecializedClassType(concreteSubtype, typeArgs, flags, node);
+                if (result.isRequired) {
+                    isRequired = true;
+                }
+                else if (result.isNotRequired) {
+                    isNotRequired = true;
+                }
+                return result.type;
             }
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 const typeResult = getTypeOfIndexedObjectOrClass(node, concreteSubtype, usage);
@@ -4607,7 +4658,81 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, isIncomplete };
+        return { type, isIncomplete, isRequired, isNotRequired };
+    }
+    // Determines the effective variance of the type parameters for a generic
+    // type alias. Normally, variance is not important for type aliases, but
+    // it can be important in cases where the type alias is used to specify
+    // a base class in a class definition.
+    function inferTypeParameterVarianceForTypeAlias(type) {
+        // If this isn't a generic type alias, there's nothing to do.
+        if (!type.typeAliasInfo || !type.typeAliasInfo.typeParameters) {
+            return undefined;
+        }
+        // Is the usage variance info already cached?
+        if (type.typeAliasInfo.usageVariance) {
+            return type.typeAliasInfo.usageVariance;
+        }
+        const typeParams = type.typeAliasInfo.typeParameters;
+        // Start with all of the usage variances unknown.
+        const usageVariances = typeParams.map(() => 1 /* Unknown */);
+        // Prepopulate the cached value for the type alias to handle
+        // recursive type aliases.
+        type.typeAliasInfo.usageVariance = usageVariances;
+        // Traverse the type alias type definition and adjust the usage
+        // variances accordingly.
+        updateUsageVariancesRecursive(type, typeParams, usageVariances);
+        return usageVariances;
+    }
+    // Looks at uses of the type parameters within the type and adjusts the
+    // variances accordingly. For example, if the type is `Mapping[T1, T2]`,
+    // then T1 will be set to invariant and T2 will be set to covariant.
+    function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return;
+        }
+        recursionCount++;
+        // Define a helper function that performs the actual usage variant update.
+        function updateUsageVarianceForType(type, variance) {
+            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                const typeParamIndex = typeAliasTypeParams.findIndex((param) => (0, types_1.isTypeSame)(param, subtype));
+                if (typeParamIndex >= 0) {
+                    usageVariances[typeParamIndex] = (0, typeUtils_1.combineVariances)(usageVariances[typeParamIndex], variance);
+                }
+                else {
+                    updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, recursionCount);
+                }
+            });
+        }
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if (subtype.category === 5 /* Function */) {
+                if (subtype.specializedTypes) {
+                    subtype.specializedTypes.parameterTypes.forEach((paramType) => {
+                        updateUsageVarianceForType(paramType, 4 /* Contravariant */);
+                    });
+                    const returnType = subtype.specializedTypes.returnType;
+                    if (returnType) {
+                        updateUsageVarianceForType(returnType, 3 /* Covariant */);
+                    }
+                }
+            }
+            else if (subtype.category === 7 /* Class */) {
+                if (subtype.typeArguments) {
+                    // If the class includes type parameters that uses auto variance,
+                    // compute the calculated variance.
+                    inferTypeParameterVarianceForClass(subtype);
+                    // Is the class specialized using any type arguments that correspond to
+                    // the type alias' type parameters?
+                    subtype.typeArguments.forEach((typeArg, classParamIndex) => {
+                        var _a;
+                        if (classParamIndex < subtype.details.typeParameters.length) {
+                            const classTypeParam = subtype.details.typeParameters[classParamIndex];
+                            updateUsageVarianceForType(typeArg, (_a = classTypeParam.computedVariance) !== null && _a !== void 0 ? _a : classTypeParam.details.declaredVariance);
+                        }
+                    });
+                }
+            }
+        });
     }
     function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4832,19 +4957,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
-    function getTypeArgs(node, flags, isAnnotatedClass = false, hasCustomClassGetItem = false, isFinalAnnotation = false, isClassVarAnnotation = false) {
+    function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
-        if (isFinalAnnotation || isClassVarAnnotation) {
+        if ((options === null || options === void 0 ? void 0 : options.isFinalAnnotation) || (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation)) {
             adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
         }
         else {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
                 32 /* DisallowParamSpec */ |
                 64 /* DisallowTypeVarTuple */ |
-                1048576 /* AllowRequired */ |
-                16384 /* EnforceTypeVarVarianceConsistency */);
-            if (!isAnnotatedClass) {
+                1048576 /* AllowRequired */);
+            if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
             adjFlags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
@@ -4855,7 +4979,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If it's a custom __class_getitem__, none of the arguments should be
             // treated as types. If it's an Annotated[a, b, c], only the first index
             // should be treated as a type. The others can be regular (non-type) objects.
-            if (hasCustomClassGetItem || (isAnnotatedClass && argIndex > 0)) {
+            if ((options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) || ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0)) {
                 typeResult = {
                     ...getTypeOfExpression(expr, 32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */ |
@@ -4865,7 +4989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags);
+                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
             }
             return typeResult;
         };
@@ -4904,7 +5028,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeArgs;
     }
-    function getTypeArg(node, flags) {
+    function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags |
             128 /* ExpectingType */ |
@@ -4925,8 +5049,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Set the node's type so it isn't reevaluated later.
             setTypeForNode(node, types_1.UnknownType.create());
         }
+        else if (node.nodeType === 15 /* Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClassType)
+                : undefined;
+            const keyTypeFallback = strClassType && (0, types_1.isInstantiableClass)(strClassType) ? strClassType : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
+            if (node.nodeType === 15 /* Dictionary */) {
+                addError(localize_1.Localizer.Diagnostic.dictInAnnotation(), node);
+            }
             // "Protocol" is not allowed as a type argument.
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
@@ -5484,6 +5622,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     : typeVarContext;
                 const effectiveTypeVarContext = (_a = typeVarContextToClone === null || typeVarContextToClone === void 0 ? void 0 : typeVarContextToClone.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
                 effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
+                if (overload.details.constructorTypeVarScopeId) {
+                    effectiveTypeVarContext.addSolveForScope(overload.details.constructorTypeVarScopeId);
+                }
                 effectiveTypeVarContext.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
@@ -5908,7 +6049,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
                 // Skip the unknown argument check if we've already checked for __init__.
-                const callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                let callResult;
+                if ((0, constructorTransform_1.hasConstructorTransform)(type)) {
+                    // Use speculative mode if we're going to later apply
+                    // a constructor transform. This allows us to use bidirectional
+                    // type inference for arguments in the transform.
+                    callResult = useSpeculativeMode(errorNode, () => {
+                        return validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                    });
+                }
+                else {
+                    callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                }
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -6123,7 +6275,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
-        const returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
+        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
         /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
             var _a, _b, _c, _d, _e, _f;
             switch (expandedSubtype.category) {
@@ -6142,6 +6294,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return expandedSubtype;
                 }
                 case 5 /* Function */: {
+                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
+                            type: printType(expandedSubtype),
+                        }), errorNode);
+                        argumentErrors = true;
+                        return undefined;
+                    }
                     // The stdlib collections/__init__.pyi stub file defines namedtuple
                     // as a function rather than a class, so we need to check for it here.
                     if (expandedSubtype.details.builtInName === 'namedtuple') {
@@ -6263,6 +6422,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             (0, types_1.isNoneInstance)(subtype)) {
                                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                                         }
+                                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                                            return types_1.FunctionType.cloneAsInstantiable(subtype);
+                                        }
                                         return types_1.AnyType.create();
                                     });
                                 }
@@ -6447,9 +6609,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return undefined;
         });
+        // If we ended up with a "Never" type because all code paths returned
+        // undefined due to argument errors, transform the result into an Unknown
+        // to avoid subsequent false positives.
+        if (argumentErrors && (0, types_1.isNever)(returnType) && !returnType.isNoReturn) {
+            returnType = types_1.UnknownType.create();
+        }
         return {
             argumentErrors,
-            returnType: (0, types_1.isNever)(returnType) && !returnType.isNoReturn ? undefined : returnType,
+            returnType,
             isTypeIncomplete,
             specializedInitSelfType,
             overloadsUsedForCall,
@@ -6504,7 +6672,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const paramDetails = (0, typeUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -6627,11 +6795,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         tooManyPositionals = true;
                     }
                     if (tooManyPositionals) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                expected: positionParamLimitIndex,
-                            }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                    expected: positionParamLimitIndex,
+                                }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                        }
                         reportedArgError = true;
                     }
                 }
@@ -6655,11 +6825,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // all positional parameters specified in the Concatenate must be
                 // filled explicitly.
                 if (typeResult.type.details.paramSpec && paramIndex < positionParamLimitIndex) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                        ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                        : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                            expected: positionParamLimitIndex,
-                        }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                expected: positionParamLimitIndex,
+                            }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                    }
                     reportedArgError = true;
                 }
                 const argType = argTypeResult.type;
@@ -6718,7 +6890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // It's not allowed to use unpacked arguments with a variadic *args
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
+                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
+                    }
                     reportedArgError = true;
                 }
                 else {
@@ -6731,7 +6905,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: argList[argIndex].valueExpression || errorNode,
+                            errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -6774,12 +6948,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         : 0 /* Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
-                            // Have we run out of arguments and still have parameters left to fill?
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
-                                ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
-                                : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
-                                    expected: remainingArgCount,
-                                }), argList[argIndex].valueExpression || errorNode);
+                            if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                // Have we run out of arguments and still have parameters left to fill?
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
+                                    ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
+                                    : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
+                                        expected: remainingArgCount,
+                                    }), argList[argIndex].valueExpression || errorNode);
+                            }
                             reportedArgError = true;
                         }
                         paramIndex++;
@@ -6854,13 +7030,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argsRemainingCount--;
             }
             if (argsRemainingCount > 0) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
-                    ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
-                    : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
-                        expected: argsRemainingCount,
-                    }), argList.length > positionalArgCount
-                    ? argList[positionalArgCount].valueExpression || errorNode
-                    : errorNode);
+                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
+                        ? localize_1.Localizer.Diagnostic.argMorePositionalExpectedOne()
+                        : localize_1.Localizer.Diagnostic.argMorePositionalExpectedCount().format({
+                            expected: argsRemainingCount,
+                        }), argList.length > positionalArgCount
+                        ? argList[positionalArgCount].valueExpression || errorNode
+                        : errorNode);
+                }
                 reportedArgError = true;
             }
         }
@@ -6934,7 +7112,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         });
                         if (!diag.isEmpty()) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
+                            if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
+                            }
                             reportedArgError = true;
                         }
                     }
@@ -6980,7 +7160,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                             }
                             if (!isValidMappingType) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
+                                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
+                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
+                                }
                                 reportedArgError = true;
                             }
                         }
@@ -7012,7 +7195,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: argList[argIndex].valueExpression || errorNode,
+                                    errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7029,7 +7212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: argList[argIndex].valueExpression || errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 // Remember that this parameter has already received a value.
@@ -7048,12 +7231,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else if (argList[argIndex].argumentCategory === 0 /* Simple */) {
-                        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                expected: positionParamLimitIndex,
-                            }), argList[argIndex].valueExpression || errorNode);
+                        if (!isDiagnosticSuppressedForNode(errorNode)) {
+                            const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                    expected: positionParamLimitIndex,
+                                }), argList[argIndex].valueExpression || errorNode);
+                        }
                         reportedArgError = true;
                     }
                     else if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
@@ -7071,7 +7256,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
-                                    errorNode: argList[argIndex].valueExpression || errorNode,
+                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                 });
                             }
                         }
@@ -7121,10 +7306,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return !entry || entry.argsReceived < entry.argsNeeded;
                 });
                 if (unassignedParams.length > 0) {
-                    const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
-                        ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
-                        : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                        const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                            ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
+                            : localize_1.Localizer.Diagnostic.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                    }
                     reportedArgError = true;
                 }
                 // Add any implicit (default) arguments that are needed for resolving
@@ -7150,7 +7337,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argumentCategory: 0 /* Simple */,
                                         typeResult: { type: defaultArgType },
                                     },
-                                    errorNode: errorNode,
+                                    errorNode,
                                     paramName: param.name,
                                     isParamNameSynthesized: param.isNameSynthesized,
                                 });
@@ -7188,7 +7375,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (containsVariadicTypeVar &&
                                 argParam.argument.argumentCategory !== 1 /* UnpackedList */ &&
                                 !argParam.mapsToVarArgList) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
+                                if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
+                                        .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
+                                }
                                 reportedArgError = true;
                             }
                             return {
@@ -8141,8 +8331,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(functionType);
             return functionType;
         }
-        if (node.nodeType === 52 /* Tuple */) {
-            node.expressions.forEach((paramExpr, index) => {
+        if (node.nodeType === 31 /* List */) {
+            node.entries.forEach((paramExpr, index) => {
                 const typeResult = getTypeOfExpressionExpectingType(paramExpr);
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* Simple */,
@@ -9210,6 +9400,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!keyTypeResult.isIncomplete && !keyTypeResult.typeErrors) {
                     verifySetEntryOrDictKeyIsHashable(entryNode.keyExpression, keyType, /* isDictKey */ true);
                 }
+                if (expectedDiagAddendum && keyTypeResult.expectedTypeDiagAddendum) {
+                    expectedDiagAddendum.addAddendum(keyTypeResult.expectedTypeDiagAddendum);
+                }
                 let valueTypeResult;
                 if (expectedTypedDictEntries &&
                     (0, types_1.isClassInstance)(keyType) &&
@@ -9239,7 +9432,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addUnknown = false;
             }
             else if (entryNode.nodeType === 16 /* DictionaryExpandEntry */) {
-                const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression);
+                // Verify that the type supports the `keys` and `__getitem__` methods.
+                // This protocol is defined in the _typeshed stub. If we can't find
+                // it there, fall back on typing.Mapping.
+                let mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
+                if (!mappingType) {
+                    mappingType = getTypingType(node, 'Mapping');
+                }
+                let expectedType;
+                if (expectedKeyType && expectedValueType) {
+                    if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
+                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(mappingType, [expectedKeyType, expectedValueType], 
+                        /* isTypeArgumentExplicit */ true));
+                    }
+                }
+                const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9263,20 +9471,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    // Verify that the type supports the `keys` and `__getitem__` methods.
-                    // This protocol is defined in the _typeshed stub. If we can't find
-                    // it there, fall back on typing.Mapping.
-                    let mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-                    if (!mappingType) {
-                        mappingType = getTypingType(node, 'Mapping');
-                    }
                     if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
                         const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
                         // Self-specialize the class.
                         mappingType = types_1.ClassType.cloneForSpecialization(mappingType, mappingType.details.typeParameters, 
                         /* isTypeArgumentExplicit */ true);
                         if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
-                        /* diag */ undefined, mappingTypeVarContext)) {
+                        /* diag */ undefined, mappingTypeVarContext, 
+                        /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
                             const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
                             const typeArgs = specializedMapping.typeArguments;
                             if (typeArgs && typeArgs.length >= 2) {
@@ -10296,16 +10498,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
     }
     function createRequiredType(classType, errorNode, isRequired, typeArgs, flags) {
-        var _a;
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
         if (!typeArgs && (flags & 256 /* ExpectingTypeAnnotation */) === 0) {
-            return classType;
+            return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
             addError(isRequired ? localize_1.Localizer.Diagnostic.requiredArgCount() : localize_1.Localizer.Diagnostic.notRequiredArgCount(), errorNode);
-            return classType;
+            return { type: classType };
         }
         const typeArgType = typeArgs[0].type;
         // Make sure this is used only in a dataclass.
@@ -10316,21 +10517,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, types_1.isInstantiableClass)(classTypeInfo.classType) &&
             types_1.ClassType.isTypedDictClass(classTypeInfo.classType)) {
             // The only legal usage is when used in a type annotation statement.
-            if (((_a = errorNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */ &&
-                errorNode.parent.typeAnnotation === errorNode) {
+            if (ParseTreeUtils.isNodeContainedWithinNodeType(errorNode, 54 /* TypeAnnotation */)) {
                 isUsageLegal = true;
             }
         }
         if ((flags & 1048576 /* AllowRequired */) !== 0) {
             isUsageLegal = true;
         }
+        // Nested Required/NotRequired are not allowed.
+        if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
+            isUsageLegal = false;
+        }
         if (!isUsageLegal) {
             addError(isRequired
                 ? localize_1.Localizer.Diagnostic.requiredNotInTypedDict()
                 : localize_1.Localizer.Diagnostic.notRequiredNotInTypedDict(), errorNode);
-            return types_1.ClassType.cloneForSpecialization(classType, [(0, typeUtils_1.convertToInstance)(typeArgType)], !!typeArgs);
+            return { type: types_1.ClassType.cloneForSpecialization(classType, [(0, typeUtils_1.convertToInstance)(typeArgType)], !!typeArgs) };
         }
-        return typeArgType;
+        return { type: typeArgType, isRequired, isNotRequired: !isRequired };
     }
     function createUnpackType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
@@ -10397,6 +10601,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isParamSpec)(typeArg.type)) {
                         addError(localize_1.Localizer.Diagnostic.paramSpecContext(), typeArg.node);
                     }
+                    else if ((0, types_1.isUnpackedVariadicTypeVar)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), typeArg.node);
+                    }
+                    else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), typeArg.node);
+                    }
                 }
             });
         }
@@ -10407,9 +10617,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addError(localize_1.Localizer.Diagnostic.annotatedTypeArgMissing(), errorNode);
         }
         if (!typeArgs || typeArgs.length === 0) {
-            return types_1.AnyType.create();
+            return { type: types_1.AnyType.create() };
         }
-        return types_1.TypeBase.cloneForAnnotated(typeArgs[0].type);
+        return {
+            type: types_1.TypeBase.cloneForAnnotated(typeArgs[0].type),
+            isRequired: typeArgs[0].isRequired,
+            isNotRequired: typeArgs[0].isNotRequired,
+        };
     }
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
@@ -10849,7 +11063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 let isSpeculativeTypeAlias = false;
                 if (isDeclaredTypeAlias(node.leftExpression)) {
                     typeAliasNameNode = node.leftExpression.valueExpression;
-                    if (!(0, declarationUtils_1.isLegalTypeAliasExpressionForm)(node.rightExpression)) {
+                    if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.rightExpression);
                     }
                 }
@@ -10946,7 +11160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function isPossibleTypeAliasOrTypedDict(decl) {
         var _a;
-        if ((0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)) {
+        if (isPossibleTypeAliasDeclaration(decl)) {
             return true;
         }
         if (decl.type === 1 /* Variable */ &&
@@ -11002,7 +11216,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = evaluateTypeParameterList(node.typeParameters);
             typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
         }
-        if (!(0, declarationUtils_1.isLegalTypeAliasExpressionForm)(node.expression)) {
+        if (!isLegalTypeAliasExpressionForm(node.expression)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.expression);
         }
         const aliasTypeResult = getTypeOfExpressionExpectingType(node.expression);
@@ -11141,7 +11355,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     argType = (0, types_1.removeUnbound)(argType);
                 }
                 if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
-                    if ((0, types_1.isClass)(argType) && types_1.TypeBase.isInstance(argType) && types_1.ClassType.isBuiltIn(argType, 'type')) {
+                    if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
+                        (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
                         argType =
                             argType.typeArguments && argType.typeArguments.length > 0
                                 ? argType.typeArguments[0]
@@ -11577,7 +11792,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Presumptively mark the variance inference as complete. This
         // prevents potential recursion.
         classType.details.requiresVarianceInference = false;
-        // Presumptively mark the computed variance to "in progress". We'll
+        // Presumptively mark the computed variance to "unknown". We'll
         // replace this below once the variance has been inferred.
         classType.details.typeParameters.forEach((param) => {
             if (param.details.declaredVariance === 0 /* Auto */) {
@@ -11614,13 +11829,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* isTypeArgumentExplicit */ true);
             const destType = types_1.ClassType.cloneForSpecialization(updatedClassType, destTypeArgs, 
             /* isTypeArgumentExplicit */ true);
-            const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType);
+            const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType, /* ignoreBaseClassVariance */ false);
             let inferredVariance;
             if (isDestSubtypeOfSrc) {
                 inferredVariance = 3 /* Covariant */;
             }
             else {
-                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType);
+                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType, /* ignoreBaseClassVariance */ false);
                 if (isSrcSubtypeOfDest) {
                     inferredVariance = 4 /* Contravariant */;
                 }
@@ -11637,9 +11852,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function evaluateTypeParameterList(node) {
         const paramTypes = [];
         node.parameters.forEach((param) => {
+            var _a;
             const paramSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
             (0, debug_1.assert)(paramSymbol);
-            const typeOfParam = getDeclaredTypeOfSymbol(paramSymbol, param.name);
+            const typeOfParam = (_a = getDeclaredTypeOfSymbol(paramSymbol, param.name)) === null || _a === void 0 ? void 0 : _a.type;
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
             }
@@ -11727,6 +11943,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     decoratorCallType.details.builtInName === 'dataclass_transform') {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
+                else if (decoratorCallType.details.name === 'deprecated') {
+                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputClassType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -11756,6 +11976,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // dependency between builtins, typing and _typeshed stubs.
                 return inputClassType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputClassType;
+            }
             if (decoratorType.details.builtInName === 'runtime_checkable') {
                 originalClassType.details.flags |= 32768 /* RuntimeCheckable */;
                 // Don't call getTypeOfDecorator for runtime_checkable. It appears
@@ -12548,6 +12772,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                     return inputFunctionType;
                 }
+                if (decoratorCallType.details.name === 'deprecated') {
+                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputFunctionType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -12563,6 +12791,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (decoratorType.details.builtInName === 'abstractmethod') {
                 return inputFunctionType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputFunctionType;
+            }
             // Handle property setters and deleters.
             if (decoratorNode.expression.nodeType === 35 /* MemberAccess */) {
                 const baseType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
@@ -12672,7 +12904,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         getTypeOfFunction(decl.node);
                     }
                 }
-                const overloadedTypes = [];
+                let overloadedTypes = [];
                 // Look at the previous declaration's type.
                 const prevDecl = decls[declIndex - 1];
                 if (prevDecl.type === 5 /* Function */) {
@@ -12694,6 +12926,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (overloadedTypes.length === 1) {
                     return overloadedTypes[0];
                 }
+                // Apply the implementation's docstring to any overloads that don't
+                // have their own docstrings.
+                const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
+                if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
+                    overloadedTypes = overloadedTypes.map((overload) => {
+                        if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
+                            return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
+                        }
+                        return overload;
+                    });
+                }
                 // Create a new overloaded type that copies the contents of the previous
                 // one and adds a new function.
                 const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
@@ -13778,22 +14021,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const aliasedName = classType.aliasName || classType.details.name;
             switch (aliasedName) {
                 case 'Callable': {
-                    return createCallableType(typeArgs, errorNode);
+                    return { type: createCallableType(typeArgs, errorNode) };
                 }
                 case 'Never': {
                     if (typeArgs && typeArgs.length > 0) {
                         addError(localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
                     }
-                    return types_1.NeverType.createNever();
+                    return { type: types_1.NeverType.createNever() };
                 }
                 case 'NoReturn': {
                     if (typeArgs && typeArgs.length > 0) {
                         addError(localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
                     }
-                    return types_1.NeverType.createNoReturn();
+                    return { type: types_1.NeverType.createNoReturn() };
                 }
                 case 'Optional': {
-                    return createOptionalType(classType, errorNode, typeArgs, flags);
+                    return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Type': {
                     // PEP 484 says that Type[Any] should be considered
@@ -13802,56 +14045,58 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         (0, types_1.isAnyOrUnknown)(typeArgs[0].type) &&
                         typeClassType &&
                         (0, types_1.isInstantiableClass)(typeClassType)) {
-                        return typeClassType;
+                        return { type: typeClassType };
                     }
                     let typeType = createSpecialType(classType, typeArgs, 1);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
-                    return typeType;
+                    return { type: typeType };
                 }
                 case 'ClassVar': {
-                    return createClassVarType(classType, errorNode, typeArgs, flags);
+                    return { type: createClassVarType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Protocol': {
-                    return createSpecialType(classType, typeArgs, 
-                    /* paramLimit */ undefined, 
-                    /* allowParamSpec */ true);
+                    return {
+                        type: createSpecialType(classType, typeArgs, 
+                        /* paramLimit */ undefined, 
+                        /* allowParamSpec */ true),
+                    };
                 }
                 case 'Tuple': {
-                    return createSpecialType(classType, typeArgs, /* paramLimit */ undefined);
+                    return { type: createSpecialType(classType, typeArgs, /* paramLimit */ undefined) };
                 }
                 case 'Union': {
-                    return createUnionType(classType, errorNode, typeArgs, flags);
+                    return { type: createUnionType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Generic': {
-                    return createGenericType(classType, errorNode, typeArgs, flags);
+                    return { type: createGenericType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Final': {
-                    return createFinalType(classType, errorNode, typeArgs, flags);
+                    return { type: createFinalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Annotated': {
                     return createAnnotatedType(errorNode, typeArgs);
                 }
                 case 'Concatenate': {
-                    return createConcatenateType(errorNode, classType, typeArgs);
+                    return { type: createConcatenateType(errorNode, classType, typeArgs) };
                 }
                 case 'TypeGuard':
                 case 'StrictTypeGuard': {
-                    return createTypeGuardType(errorNode, classType, typeArgs, flags);
+                    return { type: createTypeGuardType(errorNode, classType, typeArgs, flags) };
                 }
                 case 'Unpack': {
-                    return createUnpackType(classType, errorNode, typeArgs, flags);
+                    return { type: createUnpackType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Required':
                 case 'NotRequired': {
                     return createRequiredType(classType, errorNode, aliasedName === 'Required', typeArgs, flags);
                 }
                 case 'Self': {
-                    return createSelfType(classType, errorNode, typeArgs);
+                    return { type: createSelfType(classType, errorNode, typeArgs) };
                 }
                 case 'LiteralString': {
-                    return createSpecialType(classType, typeArgs, 0);
+                    return { type: createSpecialType(classType, typeArgs, 0) };
                 }
             }
         }
@@ -13866,7 +14111,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // PEP 484 says that type[Any] should be considered
                 // equivalent to type.
                 if (typeArgs.length === 1 && (0, types_1.isAnyOrUnknown)(typeArgs[0].type)) {
-                    return classType;
+                    return { type: classType };
                 }
                 const typeClass = getTypingType(errorNode, 'Type');
                 if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
@@ -13876,16 +14121,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
-                    return typeType;
+                    return { type: typeType };
                 }
             }
             // Handle "tuple" specially, since it needs to act like "Tuple"
             // in Python 3.9 and newer.
             if ((0, typeUtils_1.isTupleClass)(classType)) {
-                return createSpecialType(classType, typeArgs, 
-                /* paramLimit */ undefined, 
-                /* allowParamSpec */ undefined, 
-                /* isCallable */ true);
+                return {
+                    type: createSpecialType(classType, typeArgs, 
+                    /* paramLimit */ undefined, 
+                    /* allowParamSpec */ undefined, 
+                    /* isCallable */ true),
+                };
             }
         }
         let typeArgCount = typeArgs ? typeArgs.length : 0;
@@ -13894,7 +14141,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If there are no type parameters or args, the class is already specialized.
         // No need to do any more work.
         if (typeParameters.length === 0 && typeArgCount === 0) {
-            return classType;
+            return { type: classType };
         }
         const variadicTypeParamIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         if (typeArgs) {
@@ -13903,7 +14150,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (firstNonDefaultParam >= 0) {
                 minTypeArgCount = firstNonDefaultParam;
             }
-            if (typeArgCount > typeParameters.length) {
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                        name: classType.aliasName || classType.details.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                return { type: typeArgs[0].inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (typeParameters.length === 0) {
@@ -13987,7 +14245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeArgs && index < typeArgs.length) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
@@ -14057,7 +14315,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const destType = typeParameters[index];
                     const declaredVariance = destType.details.declaredVariance;
                     if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(adjustedTypeArgType, declaredVariance)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatch().format({
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForClass().format({
                             typeVarName: printType(adjustedTypeArgType),
                             className: classType.details.name,
                         }));
@@ -14087,7 +14345,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeArgTypes = typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type));
         }
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
-        return specializedClass;
+        return { type: specializedClass };
     }
     function getTypeOfArgument(arg) {
         if (arg.typeResult) {
@@ -14173,7 +14431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const scopeTypeHonorsCodeFlow = scopeType !== 1 /* Function */ && scopeType !== 0 /* ListComprehension */;
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
             // Filter the declarations based on flow reachability.
-            const reachableDecls = symbolWithScope.symbol.getDeclarations().filter((decl) => {
+            const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* Alias */ && decl.type !== 0 /* Intrinsic */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
@@ -14201,7 +14459,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // If none of the declarations are reachable from the current node,
             // search for the symbol in outer scopes.
-            if (reachableDecls.length === 0) {
+            if (!reachableDecl) {
                 if (symbolWithScope.scope.type !== 1 /* Function */) {
                     let nextScopeToSearch = symbolWithScope.scope.parent;
                     const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 3 /* Module */;
@@ -14508,59 +14766,63 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return declarations;
     }
     function getTypeForDeclaration(declaration) {
-        var _a, _b;
+        var _a, _b, _c;
         switch (declaration.type) {
             case 0 /* Intrinsic */: {
                 if (declaration.intrinsicType === 'Any') {
-                    return types_1.AnyType.create();
+                    return { type: types_1.AnyType.create() };
                 }
                 if (declaration.intrinsicType === 'class') {
                     const classNode = ParseTreeUtils.getEnclosingClass(declaration.node);
                     const classTypeInfo = getTypeOfClass(classNode);
-                    return classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
+                    return { type: classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType };
                 }
                 const strType = getBuiltInObject(declaration.node, 'str');
                 const intType = getBuiltInObject(declaration.node, 'int');
                 if ((0, types_1.isClassInstance)(intType) && (0, types_1.isClassInstance)(strType)) {
                     if (declaration.intrinsicType === 'str') {
-                        return strType;
+                        return { type: strType };
                     }
                     if (declaration.intrinsicType === 'str | None') {
-                        return (0, types_1.combineTypes)([strType, types_1.NoneType.createInstance()]);
+                        return { type: (0, types_1.combineTypes)([strType, types_1.NoneType.createInstance()]) };
                     }
                     if (declaration.intrinsicType === 'int') {
-                        return intType;
+                        return { type: intType };
                     }
                     if (declaration.intrinsicType === 'Iterable[str]') {
                         const iterableType = getBuiltInType(declaration.node, 'Iterable');
                         if ((0, types_1.isInstantiableClass)(iterableType)) {
-                            return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(iterableType, [strType], 
-                            /* isTypeArgumentExplicit */ true));
+                            return {
+                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(iterableType, [strType], 
+                                /* isTypeArgumentExplicit */ true)),
+                            };
                         }
                     }
                     if (declaration.intrinsicType === 'Dict[str, Any]') {
                         const dictType = getBuiltInType(declaration.node, 'dict');
                         if ((0, types_1.isInstantiableClass)(dictType)) {
-                            return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictType, [strType, types_1.AnyType.create()], 
-                            /* isTypeArgumentExplicit */ true));
+                            return {
+                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictType, [strType, types_1.AnyType.create()], 
+                                /* isTypeArgumentExplicit */ true)),
+                            };
                         }
                     }
                 }
-                return types_1.UnknownType.create();
+                return { type: types_1.UnknownType.create() };
             }
             case 6 /* Class */: {
                 const classTypeInfo = getTypeOfClass(declaration.node);
-                return classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType;
+                return { type: classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType };
             }
             case 7 /* SpecialBuiltInClass */: {
-                return getTypeOfAnnotation(declaration.node.typeAnnotation);
+                return { type: getTypeOfAnnotation(declaration.node.typeAnnotation) };
             }
             case 5 /* Function */: {
                 const functionTypeInfo = getTypeOfFunction(declaration.node);
-                return functionTypeInfo === null || functionTypeInfo === void 0 ? void 0 : functionTypeInfo.decoratedType;
+                return { type: functionTypeInfo === null || functionTypeInfo === void 0 ? void 0 : functionTypeInfo.decoratedType };
             }
             case 4 /* TypeAlias */: {
-                return getTypeOfTypeAlias(declaration.node);
+                return { type: getTypeOfTypeAlias(declaration.node) };
             }
             case 2 /* Parameter */: {
                 let typeAnnotationNode = declaration.node.typeAnnotation || declaration.node.typeAnnotationComment;
@@ -14579,19 +14841,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (typeAnnotationNode) {
                     const declaredType = getTypeOfParameterAnnotation(typeAnnotationNode, declaration.node.category);
-                    return transformVariadicParamType(declaration.node, declaration.node.category, adjustParameterAnnotatedType(declaration.node, declaredType));
+                    return {
+                        type: transformVariadicParamType(declaration.node, declaration.node.category, adjustParameterAnnotatedType(declaration.node, declaredType)),
+                    };
                 }
-                return undefined;
+                return { type: undefined };
             }
             case 3 /* TypeParameter */: {
-                return getTypeOfTypeParameter(declaration.node);
+                return { type: getTypeOfTypeParameter(declaration.node) };
             }
             case 1 /* Variable */: {
                 const typeAnnotationNode = declaration.typeAnnotationNode;
                 if (typeAnnotationNode) {
-                    const typeAliasNode = isDeclaredTypeAlias(typeAnnotationNode)
-                        ? ParseTreeUtils.getTypeAnnotationNode(typeAnnotationNode)
-                        : undefined;
                     let declaredType;
                     if (declaration.isRuntimeTypeExpression) {
                         declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
@@ -14608,24 +14869,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             isVariableAnnotation: true,
                             allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
                             allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
+                            allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
                         });
                     }
                     if (declaredType) {
                         // Apply enum transform if appropriate.
                         if (declaration.node.nodeType === 38 /* Name */) {
                             declaredType =
-                                (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, declaration.node, () => declaredType) || declaredType;
+                                (_c = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, declaration.node, () => declaredType)) !== null && _c !== void 0 ? _c : declaredType;
                         }
-                        if (typeAliasNode && typeAliasNode.valueExpression.nodeType === 38 /* Name */) {
-                            declaredType = transformTypeForTypeAlias(declaredType, typeAliasNode.valueExpression, declaration.node);
+                        if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
+                            return { type: undefined, isTypeAlias: true };
                         }
-                        return declaredType;
+                        return { type: declaredType };
                     }
                 }
-                return undefined;
+                return { type: undefined };
             }
             case 8 /* Alias */: {
-                return undefined;
+                return { type: undefined };
             }
         }
     }
@@ -14723,7 +14985,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
-        var _a, _b;
+        var _a, _b, _c;
         const resolvedDecl = resolveAliasDeclaration(decl, 
         /* resolveLocalNames */ true, 
         /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
@@ -14739,7 +15001,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
                 }
-                else {
+                else if (!loaderActions.implicitImports) {
                     return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
                 }
             }
@@ -14794,8 +15056,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const declaredType = getTypeForDeclaration(resolvedDecl);
-        if (declaredType) {
-            return declaredType;
+        if (declaredType.type) {
+            return declaredType.type;
         }
         // If this is part of a "py.typed" package, don't fall back on type inference
         // unless it's marked Final, is a constant, or is a declared type alias.
@@ -14815,28 +15077,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isUnambiguousType = true;
                     }
                 }
-                if (resolvedDecl.isFinal || resolvedDecl.isConstant) {
+                // Special-case constants, which are treated as unambiguous.
+                if (isFinalVariableDeclaration(resolvedDecl) || resolvedDecl.isConstant) {
                     isUnambiguousType = true;
                 }
+                // Special-case calls to certain built-in type functions.
+                if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* DoNotSpecialize */);
+                    const callType = baseTypeResult.type;
+                    if ((0, types_1.isInstantiableClass)(callType) &&
+                        types_1.ClassType.isBuiltIn(callType, [
+                            'TypeVar',
+                            'ParamSpec',
+                            'TypeVarTuple',
+                            'TypedDict',
+                            'NamedTuple',
+                            'NewType',
+                        ])) {
+                        isUnambiguousType = true;
+                    }
+                }
             }
         }
         // If the resolved declaration had no defined type, use the
         // inferred type for this node.
         if (resolvedDecl.type === 2 /* Parameter */) {
-            return (_a = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
+            return (_b = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
                 evaluateTypeOfParameter(resolvedDecl.node);
-            })) === null || _a === void 0 ? void 0 : _a.type;
+            })) === null || _b === void 0 ? void 0 : _b.type;
         }
         if (resolvedDecl.type === 1 /* Variable */ && resolvedDecl.inferredTypeSource) {
-            const isTypeAlias = (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(resolvedDecl) || isPossibleTypeAliasOrTypedDict(resolvedDecl);
+            const isTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl) || isPossibleTypeAliasOrTypedDict(resolvedDecl);
             // If this is a type alias, evaluate types for the entire assignment
             // statement rather than just the RHS of the assignment.
             const typeSource = isTypeAlias && resolvedDecl.inferredTypeSource.parent
                 ? resolvedDecl.inferredTypeSource.parent
                 : resolvedDecl.inferredTypeSource;
-            let inferredType = (_b = evaluateTypeForSubnode(resolvedDecl.node, () => {
+            let inferredType = (_c = evaluateTypeForSubnode(resolvedDecl.node, () => {
                 evaluateTypesForStatement(typeSource);
-            })) === null || _b === void 0 ? void 0 : _b.type;
+            })) === null || _c === void 0 ? void 0 : _c.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* Name */) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
                 const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
@@ -14950,28 +15229,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
         var _a, _b;
+        let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
-            const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
-            const typedDecls = symbol.getTypedDeclarations();
-            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;
+            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;
+                    }
                 }
+                const typedDecls = symbol.getTypedDeclarations();
+                const result = {
+                    type: declaredType !== null && declaredType !== void 0 ? declaredType : types_1.UnknownType.create(),
+                    isIncomplete,
+                    includesVariableDecl: typedDecls.some((decl) => decl.type === 1 /* Variable */),
+                    includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
+                    isRecursiveDefinition: !declaredType,
+                };
+                return result;
             }
-            return {
-                type: declaredType !== null && declaredType !== void 0 ? declaredType : types_1.UnknownType.create(),
-                isIncomplete,
-                includesVariableDecl: typedDecls.some((decl) => decl.type === 1 /* Variable */),
-                includesIllegalTypeAliasDecl: !typedDecls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
-                isRecursiveDefinition: !declaredType,
-            };
         }
-        // Look in the cache to see if we've computed this already.
+        // 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;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
@@ -14993,13 +15278,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let declIndexToConsider;
         // Limit the number of declarations to explore.
         if (decls.length > maxDeclarationsToUseForInference) {
-            return {
+            const result = {
                 type: types_1.UnknownType.create(),
                 isIncomplete: false,
                 includesVariableDecl: false,
-                includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
+                includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
                 isRecursiveDefinition: false,
             };
+            addToEffectiveTypeCache(result);
+            return result;
         }
         // If the caller has requested that we use only the last decl, we
         // will use only the last one, but we'll ignore decls that are in
@@ -15049,7 +15336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const resolvedDecl = (_a = resolveAliasDeclaration(decl, 
                 /* resolveLocalNames */ true, 
                 /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile)) !== null && _a !== void 0 ? _a : decl;
-                const isExplicitTypeAlias = (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl);
+                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(decl);
                 const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(decl);
                 if (isExplicitTypeAlias) {
                     sawExplicitTypeAlias = true;
@@ -15060,14 +15347,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     resolvedDecl.type === 1 /* Variable */ &&
                     ((_c = (_b = resolvedDecl.inferredTypeSource) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
                     evaluateTypesForAssignmentStatement(resolvedDecl.inferredTypeSource.parent);
-                    if (resolvedDecl.typeAliasAnnotation) {
-                        // Mark "TypeAlias" declaration as accessed.
-                        getTypeOfAnnotation(resolvedDecl.typeAliasAnnotation, {
-                            isVariableAnnotation: true,
-                            allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(resolvedDecl.node),
-                            allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(resolvedDecl.node),
-                        });
-                    }
                 }
                 if (pushSymbolResolution(symbol, decl)) {
                     try {
@@ -15085,7 +15364,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                                 let isConstant = false;
                                 if (resolvedDecl.type === 1 /* Variable */) {
-                                    if (resolvedDecl.isConstant || resolvedDecl.isFinal) {
+                                    if (resolvedDecl.isConstant || isFinalVariableDeclaration(resolvedDecl)) {
                                         isConstant = true;
                                     }
                                 }
@@ -15142,17 +15421,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: (0, types_1.combineTypes)(typesToCombine),
                 isIncomplete,
                 includesVariableDecl,
-                includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
+                includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
                 isRecursiveDefinition: false,
                 evaluationAttempts,
             };
             if (!includesSpeculativeResult) {
-                // Add the entry to the cache so we don't need to compute it next time.
-                if (!cacheEntries) {
-                    cacheEntries = new Map();
-                    effectiveTypeCache.set(symbol.id, cacheEntries);
-                }
-                cacheEntries.set(effectiveTypeCacheKey, result);
+                addToEffectiveTypeCache(result);
             }
             return result;
         }
@@ -15160,19 +15434,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type: types_1.UnboundType.create(),
             isIncomplete,
             includesVariableDecl,
-            includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
+            includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
             isRecursiveDefinition: false,
         };
+        function addToEffectiveTypeCache(result) {
+            // Add the entry to the cache so we don't need to compute it next time.
+            if (!cacheEntries) {
+                cacheEntries = new Map();
+                effectiveTypeCache.set(symbol.id, cacheEntries);
+            }
+            cacheEntries.set(effectiveTypeCacheKey, result);
+        }
     }
+    // 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
+    // explicit declared type, its type will need to be inferred instead. In some
+    // cases, non-type information (such as Final or ClassVar attributes) may be
+    // provided, but type inference is still required. In such cases, the attributes
+    // are returned as flags.
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
         const synthesizedType = symbol.getSynthesizedType();
         if (synthesizedType) {
-            return synthesizedType;
+            return { type: synthesizedType };
         }
         let typedDecls = symbol.getTypedDeclarations();
         if (typedDecls.length === 0) {
             // There was no declaration with a defined type.
-            return undefined;
+            return { type: undefined };
         }
         // If there is more than one typed decl, filter out any that are not
         // reachable from the usage node (if specified). This can happen in
@@ -15193,7 +15481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             });
             if (filteredTypedDecls.length === 0) {
-                return types_1.UnboundType.create();
+                return { type: types_1.UnboundType.create() };
             }
             typedDecls = filteredTypedDecls;
         }
@@ -15209,12 +15497,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // for recursive symbol resolution, return it as the resolved type.
             const partialType = getSymbolResolutionPartialType(symbol, decl);
             if (partialType) {
-                return partialType;
+                return { type: partialType };
             }
             if (getIndexOfSymbolResolution(symbol, decl) < 0) {
                 if (pushSymbolResolution(symbol, decl)) {
                     try {
-                        const type = getTypeForDeclaration(decl);
+                        const declaredTypeInfo = getTypeForDeclaration(decl);
                         // If there was recursion detected, don't use this declaration.
                         // The exception is it's a class declaration because getTypeOfClass
                         // handles recursion by populating a partially-created class type
@@ -15222,7 +15510,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // circular dependency between the "type" and "object" classes in
                         // builtins.pyi (since "object" is a "type" and "type" is an "object").
                         if (popSymbolResolution(symbol) || decl.type === 6 /* Class */) {
-                            return type;
+                            return declaredTypeInfo;
                         }
                     }
                     catch (e) {
@@ -15234,7 +15522,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             declIndex--;
         }
-        return undefined;
+        return { type: undefined };
     }
     function inferReturnTypeIfNecessary(type) {
         if ((0, types_1.isFunction)(type)) {
@@ -15595,18 +15883,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return false;
     }
     // This function is used to validate or infer the variance of type
-    // parameters within a class.
-    function assignClassToSelf(destType, srcType, recursionCount = 0) {
+    // parameters within a class. If ignoreBaseClassVariance is set to false,
+    // the type parameters for the base class are honored. This is useful for
+    // variance inference (PEP 695). For validation of protocol variance, we
+    // want to ignore the variance for all base classes in the class hierarchy.
+    function assignClassToSelf(destType, srcType, ignoreBaseClassVariance = true, recursionCount = 0) {
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         (0, debug_1.assert)(destType.details.typeParameters.length > 0);
         const diag = new diagnostic_1.DiagnosticAddendum();
         const typeVarContext = new typeVarContext_1.TypeVarContext();
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
+            var _a;
             if (isAssignable && symbol.isClassMember() && !symbol.isIgnoredForProtocolMatch()) {
                 const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
                 (0, debug_1.assert)(memberInfo !== undefined);
-                let destMemberType = getDeclaredTypeOfSymbol(symbol);
+                let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
                 if (destMemberType) {
                     const srcMemberType = getTypeOfMember(memberInfo);
                     destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
@@ -15624,7 +15916,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const primaryDecl = symbol.getDeclarations()[0];
                         // Class and instance variables that are mutable need to
                         // enforce invariance.
-                        const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !primaryDecl.isFinal
+                        const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !isFinalVariableDeclaration(primaryDecl)
                             ? 1 /* EnforceInvariance */
                             : 0 /* Default */;
                         if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
@@ -15644,7 +15936,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 baseClass.details.typeParameters.length > 0) {
                 const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
                 const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-                if (!assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, recursionCount)) {
+                if (!ignoreBaseClassVariance) {
+                    specializedDestBaseClass.details.typeParameters.forEach((param, index) => {
+                        if (!param.details.isParamSpec &&
+                            !param.details.isVariadic &&
+                            !param.details.isSynthesized &&
+                            specializedSrcBaseClass.typeArguments &&
+                            index < specializedSrcBaseClass.typeArguments.length &&
+                            specializedDestBaseClass.typeArguments &&
+                            index < specializedDestBaseClass.typeArguments.length) {
+                            const paramVariance = param.details.declaredVariance;
+                            if ((0, types_1.isTypeVar)(specializedSrcBaseClass.typeArguments[index])) {
+                                if (paramVariance === 2 /* Invariant */ || paramVariance === 4 /* Contravariant */) {
+                                    isAssignable = false;
+                                }
+                            }
+                            else if ((0, types_1.isTypeVar)(specializedDestBaseClass.typeArguments[index])) {
+                                if (paramVariance === 2 /* Invariant */ || paramVariance === 3 /* Covariant */) {
+                                    isAssignable = false;
+                                }
+                            }
+                        }
+                    });
+                }
+                if (isAssignable &&
+                    !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, ignoreBaseClassVariance, recursionCount)) {
                     isAssignable = false;
                 }
             }
@@ -15817,12 +16133,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return true;
     }
     function getGetterTypeFromProperty(propertyClass, inferTypeIfNeeded) {
+        var _a;
         if (!types_1.ClassType.isPropertyClass(propertyClass)) {
             return undefined;
         }
         const fgetSymbol = propertyClass.details.fields.get('fget');
         if (fgetSymbol) {
-            const fgetType = getDeclaredTypeOfSymbol(fgetSymbol);
+            const fgetType = (_a = getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
             if (fgetType && (0, types_1.isFunction)(fgetType)) {
                 return getFunctionEffectiveReturnType(fgetType, /* args */ undefined, inferTypeIfNeeded);
             }
@@ -16542,6 +16859,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
                 else if (remainingSrcSubtypes.length === 0) {
+                    if ((flags & 1024 /* PopulatingExpectedType */) !== 0) {
+                        // If we're populating an expected type, try not to leave
+                        // any TypeVars unsolved. Assign the full type to the remaining
+                        // dest TypeVars.
+                        remainingDestSubtypes.forEach((destSubtype) => {
+                            assignType(destSubtype, srcType, 
+                            /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                        });
+                    }
                     // If we've assigned all of the source subtypes but one or more dest
                     // TypeVars have gone unmatched, treat this as success.
                     return true;
@@ -17544,14 +17870,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // When a value is assigned to a variable with a declared type,
     // we may be able to narrow the type based on the assignment.
     function narrowTypeBasedOnAssignment(declaredType, assignedType) {
-        const diag = new diagnostic_1.DiagnosticAddendum();
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
                 // We can't narrow "Any".
                 if ((0, types_1.isAnyOrUnknown)(declaredType)) {
                     return declaredType;
                 }
-                if (assignType(declaredSubtype, assignedSubtype, diag)) {
+                if (assignType(declaredSubtype, assignedSubtype)) {
                     // If the source is generic and has unspecified type arguments,
                     // see if we can determine then based on the declared type.
                     if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
@@ -18035,7 +18360,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if ((0, types_1.isOverloadedFunction)(memberType)) {
             const newOverloadType = types_1.OverloadedFunctionType.create([]);
-            memberType.overloads.forEach((overload) => {
+            // Don't bother binding the implementation.
+            types_1.OverloadedFunctionType.getOverloads(memberType).forEach((overload) => {
                 const boundMethod = bindFunctionToClassOrObject(baseType, overload, memberClass, 
                 /* errorNode */ undefined, recursionCount, treatConstructorAsClassMember, firstParamType);
                 if (boundMethod) {
@@ -18072,7 +18398,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const memberTypeFirstParamType = types_1.FunctionType.getEffectiveParameterType(memberType, 0);
             // Fill out the typeVarContext for the "self" or "cls" parameter.
             typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(memberType));
-            const diag = new diagnostic_1.DiagnosticAddendum();
+            const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
             if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
                 memberTypeFirstParamType.details.boundType &&
                 (0, types_1.isClassInstance)(memberTypeFirstParamType.details.boundType) &&
@@ -18098,7 +18424,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             type: printType(baseType),
                             methodName: methodName,
                             paramName: memberTypeFirstParam.name,
-                        }) + diag.getString(), errorNode);
+                        }) + (diag === null || diag === void 0 ? void 0 : diag.getString()), errorNode);
                     }
                     else {
                         // If there was no errorNode, we couldn't report the error,
@@ -18115,6 +18441,60 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const specializedFunction = (0, typeUtils_1.applySolvedTypeVars)(memberType, typeVarContext);
         return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType, (0, typeUtils_1.getTypeVarScopeId)(baseType));
     }
+    function isFinalVariable(symbol) {
+        return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));
+    }
+    function isFinalVariableDeclaration(decl) {
+        return decl.type === 1 /* Variable */ && !!decl.isFinal;
+    }
+    function isExplicitTypeAliasDeclaration(decl) {
+        if (decl.type !== 1 /* Variable */ || !decl.typeAnnotationNode) {
+            return false;
+        }
+        if (decl.typeAnnotationNode.nodeType !== 38 /* Name */ &&
+            decl.typeAnnotationNode.nodeType !== 35 /* MemberAccess */ &&
+            decl.typeAnnotationNode.nodeType !== 48 /* StringList */) {
+            return false;
+        }
+        const type = getTypeOfAnnotation(decl.typeAnnotationNode, { isVariableAnnotation: true, allowClassVar: true });
+        return (0, types_1.isClassInstance)(type) && types_1.ClassType.isBuiltIn(type, 'TypeAlias');
+    }
+    function isPossibleTypeAliasDeclaration(decl) {
+        var _a;
+        if (decl.type !== 1 /* Variable */ || !decl.typeAliasName || decl.typeAnnotationNode) {
+            return false;
+        }
+        if (((_a = decl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 3 /* Assignment */) {
+            return false;
+        }
+        // Perform a sanity check on the RHS expression. Some expression
+        // forms should never be considered legitimate for type aliases.
+        return isLegalTypeAliasExpressionForm(decl.node.parent.rightExpression);
+    }
+    function isLegalTypeAliasExpressionForm(node) {
+        switch (node.nodeType) {
+            case 0 /* Error */:
+            case 55 /* UnaryOperation */:
+            case 4 /* AssignmentExpression */:
+            case 54 /* TypeAnnotation */:
+            case 6 /* Await */:
+            case 51 /* Ternary */:
+            case 56 /* Unpack */:
+            case 52 /* Tuple */:
+            case 9 /* Call */:
+            case 32 /* ListComprehension */:
+            case 46 /* Slice */:
+            case 60 /* Yield */:
+            case 61 /* YieldFrom */:
+            case 30 /* Lambda */:
+            case 40 /* Number */:
+            case 15 /* Dictionary */:
+            case 31 /* List */:
+            case 45 /* Set */:
+                return false;
+        }
+        return true;
+    }
     function printObjectTypeForClass(type) {
         return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
     }
@@ -18257,6 +18637,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         verifyTypeArgumentsAssignable,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,
+        isFinalVariable,
+        isFinalVariableDeclaration,
+        isExplicitTypeAliasDeclaration,
         addError,
         addWarning,
         addInformation,