@zzzen/pyright-internal 1.2.0-dev.20230618 → 1.2.0-dev.20230702

package/dist/analyzer/typeEvaluator.js

@@ -54,6 +54,7 @@ const constraintSolver_1 = require("./constraintSolver");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
+const decorators_1 = require("./decorators");
 const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
@@ -211,7 +212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeCache.size;
     }
     // This function should be called immediately prior to discarding
-    // the type evaluator. It forcibly replacing existing cache maps
+    // the type evaluator. It forcibly replaces existing cache maps
     // with empty equivalents. This shouldn't be necessary, but there
     // is apparently a bug in the v8 GC where it is unable to detect
     // circular references in complex data structures, so it fails
@@ -371,10 +372,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // context, logging any errors in the process. This may require the
     // type of surrounding statements to be evaluated.
     function getType(node) {
-        var _a;
-        return (_a = evaluateTypeForSubnode(node, () => {
+        var _a, _b;
+        let type = (_a = evaluateTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
+        // If this is a type parameter with a calculated variance, see if we
+        // can swap it out for a version that has a computed variance.
+        if (type && (0, types_1.isTypeVar)(type) && type.details.declaredVariance === 0 /* Auto */) {
+            const typeVarType = type;
+            const typeParamListNode = ParseTreeUtils.getParentNodeOfType(node, 76 /* TypeParameterList */);
+            if (((_b = typeParamListNode === null || typeParamListNode === void 0 ? void 0 : typeParamListNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 10 /* Class */) {
+                const classTypeResult = getTypeOfClass(typeParamListNode.parent);
+                if (classTypeResult) {
+                    inferTypeParameterVarianceForClass(classTypeResult.classType);
+                    const typeParam = classTypeResult.classType.details.typeParameters.find((param) => (0, types_1.isTypeSame)(param, typeVarType, { ignoreTypeFlags: true }));
+                    if (typeParam) {
+                        type = types_1.TypeBase.isInstance(type) ? types_1.TypeVarType.cloneAsInstance(typeParam) : typeParam;
+                    }
+                }
+            }
+        }
+        return type;
     }
     function getTypeResult(node) {
         return evaluateTypeForSubnode(node, () => {
@@ -446,7 +464,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
-        var _a;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -485,7 +502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // at that point.
         initializedBasicTypes(node);
         let typeResult;
-        let reportExpectingTypeErrors = (flags & 128 /* ExpectingType */) !== 0;
+        let expectingInstantiable = (flags & 128 /* ExpectingInstantiableType */) !== 0;
         switch (node.nodeType) {
             case 38 /* Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -500,11 +517,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 9 /* Call */: {
-                typeResult = getTypeOfCall(node, inferenceContext, flags);
+                typeResult = getTypeOfCall(node, flags, inferenceContext);
                 break;
             }
             case 52 /* Tuple */: {
-                typeResult = getTypeOfTuple(node, inferenceContext, flags);
+                typeResult = getTypeOfTuple(node, flags, inferenceContext);
                 break;
             }
             case 11 /* Constant */: {
@@ -516,7 +533,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (isExpectingType) {
                     // Don't report expecting type errors again. We will have already
                     // reported them when analyzing the contents of the string.
-                    reportExpectingTypeErrors = false;
+                    expectingInstantiable = false;
                 }
                 typeResult = getTypeOfStringList(node, flags, isExpectingType);
                 break;
@@ -534,7 +551,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 7 /* BinaryOperation */: {
-                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, inferenceContext, flags);
+                let effectiveFlags = flags;
+                // If we're expecting an instantiable type and this isn't a union operator,
+                // don't require that the two operands are also instantiable types.
+                if (expectingInstantiable && node.operator !== 6 /* BitwiseOr */) {
+                    effectiveFlags &= ~128 /* ExpectingInstantiableType */;
+                }
+                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext);
                 break;
             }
             case 5 /* AugmentedAssignment */: {
@@ -596,7 +619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 54 /* TypeAnnotation */: {
-                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* ExpectingType */ |
+                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* ExpectingInstantiableType */ |
                     256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
@@ -627,23 +650,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // We shouldn't get here. If we do, report an error.
             (0, debug_1.fail)(`Unhandled expression type '${ParseTreeUtils.printExpression(node)}'`);
         }
-        if (reportExpectingTypeErrors && !typeResult.isIncomplete) {
-            if (flags & 64 /* DisallowTypeVarTuple */) {
-                if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
-                    addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
-                    typeResult.type = types_1.UnknownType.create();
-                }
-            }
-            if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
-                const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
-                    types_1.ClassType.isTupleClass(typeResult.type) &&
-                    ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-                if (!isEmptyVariadic) {
-                    addExpectedClassDiagnostic(typeResult.type, node);
-                    typeResult.type = types_1.UnknownType.create();
-                    typeResult.typeErrors = true;
-                }
-            }
+        // Do we need to validate that the type is instantiable?
+        if (expectingInstantiable) {
+            validateTypeIsInstantiable(typeResult, flags, node);
         }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         // If there was an expected type, make sure that the result type is compatible.
@@ -674,6 +683,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    function validateTypeIsInstantiable(typeResult, flags, node) {
+        var _a;
+        // If the type is incomplete, don't log any diagnostics yet.
+        if (typeResult.isIncomplete) {
+            return;
+        }
+        if (flags & 64 /* DisallowTypeVarTuple */) {
+            if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
+                addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
+                typeResult.type = types_1.UnknownType.create();
+            }
+        }
+        if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
+            const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
+                types_1.ClassType.isTupleClass(typeResult.type) &&
+                ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
+            if (!isEmptyVariadic) {
+                addExpectedClassDiagnostic(typeResult.type, node);
+                typeResult.type = types_1.UnknownType.create();
+                typeResult.typeErrors = true;
+            }
+        }
+    }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         const effectiveExpectedType = inferenceContext
             ? createAwaitableReturnType(node, inferenceContext.expectedType, /* isGenerator */ false)
@@ -750,7 +782,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfStringList(node, flags, isExpectingType) {
         let typeResult;
         if (isExpectingType) {
-            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 128 /* ExpectingType */;
+            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 128 /* ExpectingInstantiableType */;
             // In most cases, annotations within a string are not parsed by the interpreter.
             // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
             if ((flags & 4194304 /* InterpreterParsesStringLiteral */) === 0) {
@@ -913,7 +945,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return specialType;
             }
         }
-        let evaluatorFlags = 128 /* ExpectingType */ |
+        let evaluatorFlags = 128 /* ExpectingInstantiableType */ |
             256 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
@@ -977,71 +1009,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return (0, typeUtils_1.convertToInstance)(annotationType);
     }
-    function getTypeOfDecorator(node, functionOrClassType) {
-        // Evaluate the type of the decorator expression.
-        let flags = AnalyzerNodeInfo.getFileInfo(node).isStubFile
-            ? 4 /* AllowForwardReferences */
-            : 0 /* None */;
-        if (node.expression.nodeType !== 9 /* Call */) {
-            flags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorTypeResult = getTypeOfExpression(node.expression, flags);
-        // Special-case typing.type_check_only. It's used in many stdlib
-        // functions, and pyright treats it as a no-op, so don't waste
-        // time evaluating it.
-        if ((0, types_1.isFunction)(decoratorTypeResult.type) &&
-            decoratorTypeResult.type.details.builtInName === 'type_check_only') {
-            return functionOrClassType;
-        }
-        // Special-case the combination of a classmethod decorator applied
-        // to a property. This is allowed in Python 3.9, but it's not reflected
-        // in the builtins.pyi stub for classmethod.
-        if ((0, types_1.isInstantiableClass)(decoratorTypeResult.type) &&
-            types_1.ClassType.isBuiltIn(decoratorTypeResult.type, 'classmethod') &&
-            (0, typeUtils_1.isProperty)(functionOrClassType)) {
-            return functionOrClassType;
-        }
-        const argList = [
-            {
-                argumentCategory: 0 /* Simple */,
-                typeResult: { type: functionOrClassType },
-            },
-        ];
-        const returnType = validateCallArguments(node.expression, argList, decoratorTypeResult, 
-        /* typeVarContext */ undefined, 
-        /* skipUnknownArgCheck */ true).returnType || types_1.UnknownType.create();
-        // If the return type is a function that has no annotations
-        // and just *args and **kwargs parameters, assume that it
-        // preserves the type of the input function.
-        if ((0, types_1.isFunction)(returnType) && !returnType.details.declaredReturnType) {
-            if (!returnType.details.parameters.some((param, index) => {
-                // Don't allow * or / separators or params with declared types.
-                if (!param.name || param.hasDeclaredType) {
-                    return true;
-                }
-                // Allow *args or **kwargs parameters.
-                if (param.category !== 0 /* Simple */) {
-                    return false;
-                }
-                // Allow inferred "self" or "cls" parameters.
-                return index !== 0 || !param.isTypeInferred;
-            })) {
-                return functionOrClassType;
-            }
-        }
-        // If the decorator is completely unannotated and the return type
-        // includes unknowns, assume that it preserves the type of the input
-        // function.
-        if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
-            if ((0, types_1.isFunction)(decoratorTypeResult.type)) {
-                if (!decoratorTypeResult.type.details.parameters.find((param) => param.typeAnnotation !== undefined) &&
-                    decoratorTypeResult.type.details.declaredReturnType === undefined) {
-                    return functionOrClassType;
-                }
-            }
-        }
-        return returnType;
-    }
     function canBeFalsy(type, recursionCount = 0) {
         type = makeTopLevelTypeVarsConcrete(type);
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -1268,21 +1235,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             memberInfo = getTypeOfClassMemberName(errorNode, classType, 
             /* isAccessedThroughObject */ false, memberName, usage, classDiag, memberAccessFlags | 1 /* AccessClassMembersOnly */, bindToType);
         }
-        // If this is a protocol class X and we're accessing a non ClassVar,
-        // emit an error.
-        if (memberInfo &&
-            memberInfo.classType &&
-            memberInfo.symbol &&
-            (0, types_1.isClass)(memberInfo.classType) &&
-            types_1.ClassType.isProtocolClass(memberInfo.classType)) {
-            const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(memberInfo.symbol);
-            if (primaryDecl && primaryDecl.type === 1 /* Variable */ && !memberInfo.isClassVar) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolMemberNotClassVar().format({
-                    memberName,
-                    className: memberInfo.classType.details.name,
-                }), errorNode);
-            }
-        }
         const isMemberPresentOnClass = (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.classType) !== undefined;
         // If it wasn't found on the class, see if it's part of the metaclass.
         if (!memberInfo) {
@@ -2905,7 +2857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(type) &&
             !type.details.isParamSpec &&
             !type.isVariadicInUnion &&
-            (flags & 128 /* ExpectingType */) === 0 &&
+            (flags & 128 /* ExpectingInstantiableType */) === 0 &&
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
             // an implied type alias where we are not expecting a type.
@@ -2925,7 +2877,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if ((flags & 128 /* ExpectingType */) !== 0) {
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericNotAllowed(), node);
@@ -3106,7 +3058,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
-            if ((flags & 128 /* ExpectingType */) !== 0 && (flags & 512 /* AllowMissingTypeArgs */) === 0) {
+            if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
+                (flags & 512 /* AllowMissingTypeArgs */) === 0) {
                 if (!type.typeAliasInfo && (0, typeUtils_1.requiresTypeArguments)(type)) {
                     if (!type.typeArguments || !type.isTypeArgumentExplicit) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
@@ -3120,7 +3073,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Is this a generic type alias that needs to be specialized?
-        if ((flags & 128 /* ExpectingType */) !== 0 &&
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
             type.typeAliasInfo &&
             type.typeAliasInfo.typeParameters &&
             type.typeAliasInfo.typeParameters.length > 0 &&
@@ -4218,7 +4171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this will generate a runtime exception in Python versions
         // less than 3.10.
-        if (flags & 128 /* ExpectingType */) {
+        if (flags & 128 /* ExpectingInstantiableType */) {
             if (node.baseExpression.nodeType === 48 /* StringList */) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 if (!fileInfo.isStubFile && fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_10) {
@@ -4550,7 +4503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
                 return concreteSubtype;
             }
-            if (flags & 128 /* ExpectingType */) {
+            if (flags & 128 /* ExpectingInstantiableType */) {
                 if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNotSubscriptable().format({
                         type: printType(unexpandedSubtype),
@@ -4565,7 +4518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
                     !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
-                    (flags & 128 /* ExpectingType */) === 0) {
+                    (flags & 128 /* ExpectingInstantiableType */) === 0) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
@@ -5072,7 +5025,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags |
-            128 /* ExpectingType */ |
+            128 /* ExpectingInstantiableType */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -5119,8 +5072,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, inferenceContext, flags) {
-        if ((flags & 128 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !inferenceContext) {
+    function getTypeOfTuple(node, flags, inferenceContext) {
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
+            node.expressions.length === 0 &&
+            !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
         // If the expected type is a union, recursively call for each of the subtypes
@@ -5272,7 +5227,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return entryTypes;
     }
-    function getTypeOfCall(node, inferenceContext, flags) {
+    function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
         // Handle immediate calls of lambdas specially.
@@ -6211,8 +6166,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // Verify that the cast is necessary.
                         const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
                         const castFromType = getTypeOfArgument(argList[1]).type;
-                        if ((0, types_1.isInstantiableClass)(castToType) && (0, types_1.isClassInstance)(castFromType)) {
-                            if ((0, types_1.isTypeSame)(castToType, types_1.ClassType.cloneAsInstantiable(castFromType), {
+                        if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
+                            if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                                 ignorePseudoGeneric: true,
                             })) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
@@ -6909,7 +6864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argType = getTypeOfArgument(argList[argIndex]).type;
+                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType)).type;
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
                     }
@@ -7693,6 +7648,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
     function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        var _a;
+        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, errorNode.start);
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
@@ -7708,7 +7666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, signatureTracker));
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
@@ -7902,7 +7860,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         8 /* EvaluateStringLiteralAsType */ |
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
-                    : 0 /* None */;
+                    : 2 /* DoNotSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
@@ -7937,15 +7895,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.isinstanceParam && !argParam.argument.typeResult && argParam.argument.valueExpression) {
-                const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
-                    32 /* DisallowParamSpec */ |
-                    64 /* DisallowTypeVarTuple */);
-                argType = argTypeResult.type;
-                if (argTypeResult.isIncomplete) {
-                    isTypeIncomplete = true;
-                }
-            }
             else {
                 const argTypeResult = getTypeOfArgument(argParam.argument);
                 argType = argTypeResult.type;
@@ -8461,7 +8410,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = [];
             let isTypeParamListValid = true;
             typeParamsExpr.expressions.map((expr) => {
-                let entryType = getTypeOfExpression(expr, 128 /* ExpectingType */).type;
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
                     if (entryType.scopeId) {
                         isTypeParamListValid = false;
@@ -8481,7 +8430,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
-        /* typeParamNodes */ undefined, () => typeParameters);
+        /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
     }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* Constant */) {
@@ -8615,7 +8564,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.constType === 26 /* None */) {
-            type = (flags & 128 /* ExpectingType */) !== 0 ? types_1.NoneType.createType() : types_1.NoneType.createInstance();
+            type =
+                (flags & 128 /* ExpectingInstantiableType */) !== 0
+                    ? types_1.NoneType.createType()
+                    : types_1.NoneType.createInstance();
         }
         else if (node.constType === 33 /* True */ ||
             node.constType === 15 /* False */ ||
@@ -9305,13 +9257,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For now, use only the first expected type.
         const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined;
         let paramsArePositionOnly = true;
+        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : undefined;
         node.parameters.forEach((param, index) => {
-            let paramType = types_1.UnknownType.create();
-            if (expectedFunctionType && index < expectedFunctionType.details.parameters.length) {
-                paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
+            let paramType;
+            if (expectedParamDetails) {
+                if (index < expectedParamDetails.params.length) {
+                    paramType = expectedParamDetails.params[index].type;
+                }
+                else if (param.defaultValue) {
+                    // If the lambda param has a default value but there is no associated
+                    // parameter in the expected type, assume that the default value is
+                    // being used to explicitly capture a value from an outer scope. Infer
+                    // its type from the default value expression.
+                    paramType = getTypeOfExpression(param.defaultValue, undefined, inferenceContext).type;
+                }
             }
             if (param.name) {
-                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType) }, 0 /* None */);
+                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* None */);
             }
             if (param.defaultValue) {
                 // Evaluate the default value if it's present.
@@ -9349,7 +9311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 hasDefault: !!param.defaultValue,
                 defaultValueExpression: param.defaultValue,
                 hasDeclaredType: true,
-                type: paramType,
+                type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
             };
             types_1.FunctionType.addParameter(functionType, functionParam);
         });
@@ -9655,11 +9617,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         hasDeclaredType: true,
                     });
                 });
-                types_1.FunctionType.addParameter(functionType, {
-                    category: 0 /* Simple */,
-                    isNameSynthesized: false,
-                    type: types_1.UnknownType.create(),
-                });
+                if (typeList.length > 0) {
+                    // Add a positional-only separator to the end of the parameter list.
+                    types_1.FunctionType.addParameter(functionType, {
+                        category: 0 /* Simple */,
+                        isNameSynthesized: false,
+                        type: types_1.UnknownType.create(),
+                    });
+                }
             }
             else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
                 types_1.FunctionType.addDefaultParameters(functionType);
@@ -9918,7 +9883,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
-            const functionFlags = getFunctionFlagsFromDecorators(enclosingFunction, /* isInClass */ true);
+            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, enclosingFunction, 
+            /* isInClass */ true);
             const isInnerFunction = !!ParseTreeUtils.getEnclosingFunction(enclosingFunction);
             if (!isInnerFunction) {
                 // Check for static methods.
@@ -10502,7 +10468,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (isDeclaredTypeAlias(node.leftExpression)) {
             flags |=
-                128 /* ExpectingType */ |
+                128 /* ExpectingInstantiableType */ |
                     256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
@@ -10788,7 +10754,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
-        let exprFlags = 128 /* ExpectingType */ |
+        let exprFlags = 128 /* ExpectingInstantiableType */ |
             1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
@@ -11123,7 +11089,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
-            const newDecoratedType = applyClassDecorator(decoratedType, classType, decorator);
+            const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
@@ -11391,95 +11357,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
         }
     }
-    function applyClassDecorator(inputClassType, originalClassType, decoratorNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        let flags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-        if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-            flags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorType = getTypeOfExpression(decoratorNode.expression, flags).type;
-        if (decoratorNode.expression.nodeType === 9 /* Call */) {
-            const decoratorCallType = getTypeOfExpression(decoratorNode.expression.leftExpression, flags | 2 /* DoNotSpecialize */).type;
-            if ((0, types_1.isFunction)(decoratorCallType)) {
-                if (decoratorCallType.details.name === '__dataclass_transform__' ||
-                    decoratorCallType.details.builtInName === 'dataclass_transform') {
-                    originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-                }
-                else if (decoratorCallType.details.builtInName === 'deprecated') {
-                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputClassType;
-                }
-            }
-            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-                if (decoratorCallType.overloads.length > 0 &&
-                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
-                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputClassType;
-                }
-            }
-        }
-        if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-            const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
-            if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, 
-                /* callNode */ undefined);
-                return inputClassType;
-            }
-            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
-                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputClassType;
-            }
-        }
-        else if ((0, types_1.isFunction)(decoratorType)) {
-            if (decoratorType.details.builtInName === 'final') {
-                originalClassType.details.flags |= 4096 /* Final */;
-                // Don't call getTypeOfDecorator for final. We'll hard-code its
-                // behavior because its function definition results in a cyclical
-                // 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
-                // frequently in stubs, and it's a waste of time to validate its
-                // parameters.
-                return inputClassType;
-            }
-            // Is this a dataclass decorator?
-            let dataclassBehaviors;
-            let callNode;
-            if (decoratorNode.expression.nodeType === 9 /* Call */) {
-                callNode = decoratorNode.expression;
-                const decoratorCallType = getTypeOfExpression(callNode.leftExpression, flags | 2 /* DoNotSpecialize */).type;
-                dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorCallType);
-            }
-            else {
-                const decoratorType = getTypeOfExpression(decoratorNode.expression, flags).type;
-                dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
-            }
-            if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, callNode);
-                return inputClassType;
-            }
-        }
-        return getTypeOfDecorator(decoratorNode, inputClassType);
-    }
-    // Given a @typing.deprecated decorator node, returns either '' or a custom
-    // deprecation message if one is provided.
-    function getCustomDeprecationMessage(decorator) {
-        if (decorator.expression.nodeType === 9 /* Call */ &&
-            decorator.expression.arguments.length > 0 &&
-            decorator.expression.arguments[0].argumentCategory === 0 /* Simple */ &&
-            decorator.expression.arguments[0].valueExpression.nodeType === 48 /* StringList */ &&
-            decorator.expression.arguments[0].valueExpression.strings.length === 1) {
-            return decorator.expression.arguments[0].valueExpression.strings[0].value;
-        }
-        return '';
-    }
     // Runs any registered "callback hooks" that depend on the specified class type.
     // This allows us to complete any work that requires dependent classes to be
     // completed.
@@ -11626,7 +11503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             containingClassType = classInfo.classType;
         }
-        let functionFlags = getFunctionFlagsFromDecorators(node, !!containingClassNode);
+        let functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, node, !!containingClassNode);
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
             functionFlags |= 16 /* Generator */;
         }
@@ -11952,7 +11829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
-            const newDecoratedType = applyFunctionDecorator(decoratedType, functionType, decorator, node);
+            const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
@@ -11974,7 +11851,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     markParamAccessed(param);
                 });
             }
-            decoratedType = addOverloadsToFunctionType(node, decoratedType);
+            decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
         writeTypeCache(node.name, { type: functionType }, 0 /* None */);
         writeTypeCache(node, { type: decoratedType }, 0 /* None */);
@@ -12055,6 +11932,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const baseClassParamAnnotation = (_a = baseClassParam.typeAnnotation) !== null && _a !== void 0 ? _a : baseClassParam.typeAnnotationComment;
                         if (baseClassParamAnnotation) {
                             let inferredParamType = getTypeOfParameterAnnotation(baseClassParamAnnotation, functionNode.parameters[paramIndex].category);
+                            // If the parameter type is generic, specialize it in the context
+                            // of the child class.
+                            if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
+                                const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClassMemberInfo.classType);
+                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext);
+                            }
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
                             if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
                                 inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
@@ -12147,268 +12030,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    // Scans through the decorators to find a few built-in decorators
-    // that affect the function flags.
-    function getFunctionFlagsFromDecorators(node, isInClass) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        let flags = 0 /* None */;
-        if (isInClass) {
-            // The "__new__" magic method is not an instance method.
-            // It acts as a static method instead.
-            if (node.name.value === '__new__') {
-                flags |= 1 /* ConstructorMethod */;
-            }
-            // Several magic methods are treated as class methods implicitly
-            // by the runtime. Check for these here.
-            const implicitClassMethods = ['__init_subclass__', '__class_getitem__'];
-            if (implicitClassMethods.some((name) => node.name.value === name)) {
-                flags |= 2 /* ClassMethod */;
-            }
-        }
-        for (const decoratorNode of node.decorators) {
-            // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-            let evaluatorFlags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-            if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-                evaluatorFlags |= 2 /* DoNotSpecialize */;
-            }
-            const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-            const decoratorType = decoratorTypeResult.type;
-            if ((0, types_1.isFunction)(decoratorType)) {
-                if (decoratorType.details.builtInName === 'abstractmethod') {
-                    if (isInClass) {
-                        flags |= 8 /* AbstractMethod */;
-                    }
-                }
-                else if (decoratorType.details.builtInName === 'final') {
-                    flags |= 8192 /* Final */;
-                }
-                else if (decoratorType.details.builtInName === 'override') {
-                    flags |= 262144 /* Overridden */;
-                }
-            }
-            else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-                if (types_1.ClassType.isBuiltIn(decoratorType, 'staticmethod')) {
-                    if (isInClass) {
-                        flags |= 4 /* StaticMethod */;
-                    }
-                }
-                else if (types_1.ClassType.isBuiltIn(decoratorType, 'classmethod')) {
-                    if (isInClass) {
-                        flags |= 2 /* ClassMethod */;
-                    }
-                }
-            }
-        }
-        return flags;
-    }
-    // Transforms the input function type into an output type based on the
-    // decorator function described by the decoratorNode.
-    function applyFunctionDecorator(inputFunctionType, undecoratedType, decoratorNode, functionNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-        let evaluatorFlags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-        if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-            evaluatorFlags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-        const decoratorType = decoratorTypeResult.type;
-        // Special-case the "overload" because it has no definition. Older versions of typeshed
-        // defined "overload" as an object, but newer versions define it as a function.
-        if (((0, types_1.isInstantiableClass)(decoratorType) && types_1.ClassType.isSpecialBuiltIn(decoratorType, 'overload')) ||
-            ((0, types_1.isFunction)(decoratorType) && decoratorType.details.builtInName === 'overload')) {
-            if ((0, types_1.isFunction)(inputFunctionType)) {
-                inputFunctionType.details.flags |= 256 /* Overloaded */;
-                undecoratedType.details.flags |= 256 /* Overloaded */;
-                return inputFunctionType;
-            }
-        }
-        if (decoratorNode.expression.nodeType === 9 /* Call */) {
-            const decoratorCallType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
-            if ((0, types_1.isFunction)(decoratorCallType)) {
-                if (decoratorCallType.details.name === '__dataclass_transform__' ||
-                    decoratorCallType.details.builtInName === 'dataclass_transform') {
-                    undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-                    return inputFunctionType;
-                }
-                if (decoratorCallType.details.builtInName === 'deprecated') {
-                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputFunctionType;
-                }
-            }
-            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-                if (decoratorCallType.overloads.length > 0 &&
-                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
-                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputFunctionType;
-                }
-            }
-        }
-        let returnType = getTypeOfDecorator(decoratorNode, inputFunctionType);
-        // Check for some built-in decorator types with known semantics.
-        if ((0, types_1.isFunction)(decoratorType)) {
-            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;
-                if ((0, typeUtils_1.isProperty)(baseType)) {
-                    const memberName = decoratorNode.expression.memberName.value;
-                    if (memberName === 'setter') {
-                        if ((0, types_1.isFunction)(inputFunctionType)) {
-                            (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                            return (0, properties_1.clonePropertyWithSetter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                        }
-                        else {
-                            return inputFunctionType;
-                        }
-                    }
-                    else if (memberName === 'deleter') {
-                        if ((0, types_1.isFunction)(inputFunctionType)) {
-                            (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                            return (0, properties_1.clonePropertyWithDeleter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                        }
-                        else {
-                            return inputFunctionType;
-                        }
-                    }
-                }
-            }
-        }
-        else if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
-                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputFunctionType;
-            }
-        }
-        else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-            if (types_1.ClassType.isBuiltIn(decoratorType)) {
-                switch (decoratorType.details.name) {
-                    case 'classmethod':
-                    case 'staticmethod': {
-                        const requiredFlag = decoratorType.details.name === 'classmethod'
-                            ? 2 /* ClassMethod */
-                            : 4 /* StaticMethod */;
-                        // If the function isn't currently a class method or static method
-                        // (which can happen if the function was wrapped in a decorator),
-                        // add the appropriate flag.
-                        if ((0, types_1.isFunction)(inputFunctionType) && (inputFunctionType.details.flags & requiredFlag) === 0) {
-                            const newFunction = types_1.FunctionType.clone(inputFunctionType);
-                            newFunction.details.flags &= ~(1 /* ConstructorMethod */ |
-                                4 /* StaticMethod */ |
-                                2 /* ClassMethod */);
-                            newFunction.details.flags |= requiredFlag;
-                            return newFunction;
-                        }
-                        return inputFunctionType;
-                    }
-                }
-            }
-            // Handle properties and subclasses of properties specially.
-            if (types_1.ClassType.isPropertyClass(decoratorType)) {
-                if ((0, types_1.isFunction)(inputFunctionType)) {
-                    (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                    return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, inputFunctionType);
-                }
-                else if ((0, types_1.isClassInstance)(inputFunctionType)) {
-                    const boundMethod = getBoundMethod(inputFunctionType, '__call__');
-                    if (boundMethod && (0, types_1.isFunction)(boundMethod)) {
-                        return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, boundMethod);
-                    }
-                    return types_1.UnknownType.create();
-                }
-            }
-        }
-        if ((0, types_1.isFunction)(inputFunctionType) && (0, types_1.isFunction)(returnType)) {
-            returnType = types_1.FunctionType.clone(returnType);
-            // Copy the overload flag from the input function type.
-            if (types_1.FunctionType.isOverloaded(inputFunctionType)) {
-                returnType.details.flags |= 256 /* Overloaded */;
-            }
-            // Copy the docstrings from the input function type if the
-            // decorator didn't have its own docstring.
-            if (!returnType.details.docString) {
-                returnType.details.docString = inputFunctionType.details.docString;
-            }
-        }
-        return returnType;
-    }
-    // Given a function node and the function type associated with it, this
-    // method searches for prior function nodes that are marked as @overload
-    // and creates an OverloadedFunctionType that includes this function and
-    // all previous ones.
-    function addOverloadsToFunctionType(node, type) {
-        let functionDecl;
-        const decl = AnalyzerNodeInfo.getDeclaration(node);
-        if (decl) {
-            functionDecl = decl;
-        }
-        const symbolWithScope = lookUpSymbolRecursive(node, node.name.value, /* honorCodeFlow */ false);
-        if (symbolWithScope) {
-            const decls = symbolWithScope.symbol.getDeclarations();
-            // Find this function's declaration.
-            const declIndex = decls.findIndex((decl) => decl === functionDecl);
-            if (declIndex > 0) {
-                // Evaluate all of the previous function declarations. They will
-                // be cached. We do it in this order to avoid a stack overflow due
-                // to recursion if there is a large number (1000's) of overloads.
-                for (let i = 0; i < declIndex; i++) {
-                    const decl = decls[i];
-                    if (decl.type === 5 /* Function */) {
-                        getTypeOfFunction(decl.node);
-                    }
-                }
-                let overloadedTypes = [];
-                // Look at the previous declaration's type.
-                const prevDecl = decls[declIndex - 1];
-                if (prevDecl.type === 5 /* Function */) {
-                    const prevDeclDeclTypeInfo = getTypeOfFunction(prevDecl.node);
-                    if (prevDeclDeclTypeInfo) {
-                        if ((0, types_1.isFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                            if (types_1.FunctionType.isOverloaded(prevDeclDeclTypeInfo.decoratedType)) {
-                                overloadedTypes.push(prevDeclDeclTypeInfo.decoratedType);
-                            }
-                        }
-                        else if ((0, types_1.isOverloadedFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                            // If the previous declaration was itself an overloaded function,
-                            // copy the entries from it.
-                            (0, collectionUtils_1.appendArray)(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.overloads);
-                        }
-                    }
-                }
-                overloadedTypes.push(type);
-                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);
-                const prevOverload = overloadedTypes[overloadedTypes.length - 2];
-                const isPrevOverloadAbstract = types_1.FunctionType.isAbstractMethod(prevOverload);
-                const isCurrentOverloadAbstract = types_1.FunctionType.isAbstractMethod(type);
-                if (isPrevOverloadAbstract !== isCurrentOverloadAbstract) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadAbstractMismatch().format({ name: node.name.value }), node.name);
-                }
-                return newOverload;
-            }
-        }
-        return type;
-    }
     function createAsyncFunction(node, functionType) {
         // Clone the original function and replace its return type with an
         // Awaitable[<returnType>].
@@ -13314,7 +12935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // See if the function is a method in a child class. We may be able to
         // infer the type of the parameter from a method of the same name in
         // a parent class if it has an annotated type.
-        const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
+        const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, functionNode, /* isInClass */ true);
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
         writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
@@ -13823,7 +13444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         return { type: specializedClass };
     }
-    function getTypeOfArgument(arg) {
+    function getTypeOfArgument(arg, inferenceContext) {
         if (arg.typeResult) {
             return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
@@ -13833,7 +13454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
-        return getTypeOfExpression(arg.valueExpression);
+        return getTypeOfExpression(arg.valueExpression, /* flags */ undefined, inferenceContext);
     }
     // This function is like getTypeOfArgument except that it is
     // used in cases where the argument is expected to be a type
@@ -13848,7 +13469,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getTypeOfExpressionExpectingType(arg.valueExpression);
     }
     function getTypeOfExpressionExpectingType(node, options) {
-        let flags = 128 /* ExpectingType */ | 8 /* EvaluateStringLiteralAsType */ | 131072 /* DisallowClassVar */;
+        let flags = 128 /* ExpectingInstantiableType */ |
+            8 /* EvaluateStringLiteralAsType */ |
+            131072 /* DisallowClassVar */;
         if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
             flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
         }
@@ -15420,34 +15043,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         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 = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (destMemberType) {
-                    const srcMemberType = getTypeOfMember(memberInfo);
-                    destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
-                    // Properties require special processing.
-                    if ((0, types_1.isClassInstance)(destMemberType) &&
-                        types_1.ClassType.isPropertyClass(destMemberType) &&
-                        (0, types_1.isClassInstance)(srcMemberType) &&
-                        types_1.ClassType.isPropertyClass(srcMemberType)) {
-                        if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
-                        /* selfTypeVarContext */ undefined, recursionCount)) {
-                            isAssignable = false;
-                        }
+            if (!isAssignable || !symbol.isClassMember() || symbol.isIgnoredForProtocolMatch()) {
+                return;
+            }
+            // Constructor methods are exempt from variance calculations.
+            if (name === '__new__' || name === '__init__') {
+                return;
+            }
+            const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
+            (0, debug_1.assert)(memberInfo !== undefined);
+            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);
+                // Properties require special processing.
+                if ((0, types_1.isClassInstance)(destMemberType) &&
+                    types_1.ClassType.isPropertyClass(destMemberType) &&
+                    (0, types_1.isClassInstance)(srcMemberType) &&
+                    types_1.ClassType.isPropertyClass(srcMemberType)) {
+                    if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                    /* selfTypeVarContext */ undefined, recursionCount)) {
+                        isAssignable = false;
                     }
-                    else {
-                        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 */ && !isFinalVariableDeclaration(primaryDecl)
-                            ? 1 /* EnforceInvariance */
-                            : 0 /* Default */;
-                        if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
-                        /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                            isAssignable = false;
-                        }
+                }
+                else {
+                    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 */ && !isFinalVariableDeclaration(primaryDecl)
+                        ? 1 /* EnforceInvariance */
+                        : 0 /* Default */;
+                    if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                    /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                        isAssignable = false;
                     }
                 }
             }
@@ -15544,7 +15172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignTupleTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
@@ -15586,32 +15214,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
         let prevSrcType;
-        let curDestTypeVarContext = destTypeVarContext;
-        let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
-        effectiveFlags |= 8 /* SkipSolveTypeVars */;
-        if (!destTypeVarContext) {
-            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
-            effectiveFlags &= ~8 /* SkipSolveTypeVars */;
+        // If we're enforcing invariance, literal types must match.
+        if ((flags & 1 /* EnforceInvariance */) !== 0) {
+            const srcIsLiteral = srcType.literalValue !== undefined;
+            const destIsLiteral = destType.literalValue !== undefined;
+            if (srcIsLiteral !== destIsLiteral) {
+                return false;
+            }
         }
         else {
-            // If we're using the caller's type var context, don't solve the
-            // type vars in this pass. We'll do this after we're done looping
-            // through the inheritance chain.
-            effectiveFlags |= 8 /* SkipSolveTypeVars */;
+            // If the dest is an 'object', it's assignable.
+            if (types_1.ClassType.isBuiltIn(destType, 'object')) {
+                return true;
+            }
         }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
-            const curSrcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(curSrcType));
             // If we've hit an "unknown", all bets are off, and we need to assume
             // that the type is assignable.
             if ((0, types_1.isUnknown)(ancestorType)) {
                 return true;
             }
-            // If we've hit an 'object', it's assignable.
-            if (types_1.ClassType.isBuiltIn(ancestorType, 'object')) {
-                return true;
-            }
             // If this isn't the first time through the loop, specialize
             // for the next ancestor in the chain.
             if (ancestorIndex < inheritanceChain.length - 1) {
@@ -15626,11 +15250,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 curSrcType = (0, typeUtils_1.specializeForBaseClass)(effectiveCurSrcType, ancestorType);
             }
-            // Handle built-in types that support arbitrary numbers
-            // of type parameters like Tuple.
-            if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-                return assignTupleTypeArgs(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
-            }
             // If there are no type parameters on this class, we're done.
             const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
             if (ancestorTypeParams.length === 0) {
@@ -15640,13 +15259,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!ancestorType.typeArguments) {
                 return true;
             }
-            // Validate that the type arguments match.
-            if (!verifyTypeArgumentsAssignable(ancestorType, curSrcType, diag, curDestTypeVarContext, curSrcTypeVarContext, effectiveFlags, recursionCount)) {
-                return false;
-            }
-            // Allocate a new type var map for the next time through the loop.
-            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
-            effectiveFlags &= ~8 /* SkipSolveTypeVars */;
             prevSrcType = curSrcType;
         }
         // If we're enforcing invariance, literal types must match as well.
@@ -15657,17 +15269,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return false;
             }
         }
+        // Handle tuple, which supports a variable number of type arguments.
+        if (destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
+            return assignTupleTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+        }
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
             // type arguments are assignable to the dest type arguments.
-            if (!verifyTypeArgumentsAssignable(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                return false;
-            }
+            return assignTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
         }
-        else if (destTypeVarContext &&
-            destType.details.typeParameters.length > 0 &&
-            curSrcType.typeArguments &&
-            !destTypeVarContext.isLocked()) {
+        if (destTypeVarContext && curSrcType.typeArguments && !destTypeVarContext.isLocked()) {
             // Populate the typeVar map with type arguments of the source.
             const srcTypeArgs = curSrcType.typeArguments;
             for (let i = 0; i < destType.details.typeParameters.length; i++) {
@@ -15693,7 +15304,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function verifyTypeArgumentsAssignable(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         inferTypeParameterVarianceForClass(destType);
@@ -15754,7 +15365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 /* EnforceInvariance */, recursionCount)) {
+                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 /* EnforceInvariance */ | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         // Don't report errors with type variables in "pseudo-random"
                         // classes since these type variables are not real.
                         if (!types_1.ClassType.isPseudoGenericClass(destType)) {
@@ -16262,7 +15873,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(concreteSrcType)), flags, recursionCount)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
                     return true;
                 }
             }
@@ -17213,7 +16824,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // remaining parameters.
                         if (remainingParams.length > 0 ||
                             !srcParamSpec ||
-                            !assignType(destParamSpec, (0, typeUtils_1.convertToInstance)(srcParamSpec), 
+                            !assignType((0, typeUtils_1.convertToInstance)(destParamSpec), (0, typeUtils_1.convertToInstance)(srcParamSpec), 
                             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                             canAssign = false;
                         }
@@ -17833,7 +17444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let isAbstract;
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
                         if (decl && decl.type === 5 /* Function */) {
-                            const functionFlags = getFunctionFlagsFromDecorators(decl.node, true);
+                            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, decl.node, true);
                             isAbstract = !!(functionFlags & 8 /* AbstractMethod */);
                         }
                         else {
@@ -17964,7 +17575,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!assignType(memberTypeFirstParamType, firstParamType, diag, typeVarContext, 
-            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+            /* srcTypeVarContext */ undefined, 2048 /* AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {
@@ -18066,6 +17677,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.printUnknownWithAny) {
             flags |= 1 /* PrintUnknownWithAny */;
         }
+        if (options === null || options === void 0 ? void 0 : options.printTypeVarVariance) {
+            flags |= 2048 /* PrintTypeVarVariance */;
+        }
         if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
             flags |= 2 /* OmitTypeArgumentsIfUnknown */;
         }
@@ -18208,7 +17822,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getObjectType,
         getBuiltInObject,
         getTypingType,
-        verifyTypeArgumentsAssignable,
+        assignTypeArguments,
         reportMissingTypeArguments,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,