@zzzen/pyright-internal 1.2.0-dev.20240519 → 1.2.0-dev.20240526

package/dist/analyzer/typeEvaluator.js

@@ -509,7 +509,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function getTypeOfExpression(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext) {
+    function getTypeOfExpression(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext, signatureTracker) {
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -547,9 +547,55 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // needed in assignType, but we don't have access to the parse tree
         // at that point.
         initializedBasicTypes(node);
+        let typeResult = getTypeOfExpressionCore(node, flags, inferenceContext, signatureTracker);
+        // Should we disable type promotions for bytes?
+        if ((0, types_1.isInstantiableClass)(typeResult.type) &&
+            typeResult.type.includePromotions &&
+            !typeResult.type.includeSubclasses &&
+            types_1.ClassType.isBuiltIn(typeResult.type, 'bytes')) {
+            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
+                typeResult = {
+                    ...typeResult,
+                    type: types_1.ClassType.cloneRemoveTypePromotions(typeResult.type),
+                };
+            }
+        }
+        // Don't allow speculative caching for assignment expressions because
+        // the target name node won't have a corresponding type cached speculatively.
+        const allowSpeculativeCaching = node.nodeType !== 4 /* ParseNodeType.AssignmentExpression */;
+        writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching);
+        // If there was an expected type, make sure that the result type is compatible.
+        if (inferenceContext &&
+            !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
+            !(0, types_1.isNever)(inferenceContext.expectedType)) {
+            expectedTypeCache.set(node.id, inferenceContext.expectedType);
+            // If this is a generic function and there is a signature tracker,
+            // make sure the signature is unique.
+            if (signatureTracker && (0, types_1.isFunction)(typeResult.type)) {
+                typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, node.start);
+            }
+            if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                // Make sure the resulting type is assignable to the expected type.
+                if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
+                /* destTypeVarContext */ undefined, 
+                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    typeResult.typeErrors = true;
+                    typeResult.expectedTypeDiagAddendum = diag;
+                    diag.addTextRange(node);
+                }
+            }
+        }
+        if (printExpressionTypes) {
+            printExpressionSpaceCount--;
+            console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Post ${printType(typeResult.type)}${typeResult.isIncomplete ? ' Incomplete' : ''}`);
+        }
+        return typeResult;
+    }
+    // This is a helper function that implements the core of getTypeOfExpression.
+    function getTypeOfExpressionCore(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext, signatureTracker) {
         let typeResult;
         let expectingInstantiable = (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0;
-        let allowSpeculativeCaching = true;
         switch (node.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -564,11 +610,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 9 /* ParseNodeType.Call */: {
-                typeResult = getTypeOfCall(node, flags, inferenceContext);
+                typeResult = getTypeOfCall(node, flags, inferenceContext, signatureTracker);
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                typeResult = getTypeOfTuple(node, flags, inferenceContext);
+                typeResult = getTypeOfTuple(node, flags, inferenceContext, signatureTracker);
                 break;
             }
             case 11 /* ParseNodeType.Constant */: {
@@ -629,7 +675,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 32 /* ParseNodeType.ListComprehension */: {
-                typeResult = getTypeOfListComprehension(node, inferenceContext);
+                typeResult = getTypeOfListComprehension(node, flags, inferenceContext);
                 break;
             }
             case 15 /* ParseNodeType.Dictionary */: {
@@ -641,7 +687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 3 /* ParseNodeType.Assignment */: {
-                typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext);
+                typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext, signatureTracker);
                 assignTypeToExpression(node.leftExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true, 
                 /* allowAssignmentToFinalVar */ true);
@@ -651,12 +697,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
                     addError(localize_1.LocMessage.walrusNotAllowed(), node);
                 }
-                typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext);
+                typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext, signatureTracker);
                 assignTypeToExpression(node.name, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true);
-                // Don't allow speculative caching for assignment expressions because
-                // the target name node won't have a corresponding type cached speculatively.
-                allowSpeculativeCaching = false;
                 break;
             }
             case 60 /* ParseNodeType.Yield */: {
@@ -707,45 +750,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (expectingInstantiable) {
             validateTypeIsInstantiable(typeResult, flags, node);
         }
-        // Should we disable type promotions for bytes?
-        if ((0, types_1.isInstantiableClass)(typeResult.type) &&
-            typeResult.type.includePromotions &&
-            !typeResult.type.includeSubclasses &&
-            types_1.ClassType.isBuiltIn(typeResult.type, 'bytes')) {
-            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
-                typeResult = {
-                    ...typeResult,
-                    type: types_1.ClassType.cloneRemoveTypePromotions(typeResult.type),
-                };
-            }
-        }
-        writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching);
-        // If there was an expected type, make sure that the result type is compatible.
-        if (inferenceContext &&
-            !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
-            !(0, types_1.isNever)(inferenceContext.expectedType)) {
-            expectedTypeCache.set(node.id, inferenceContext.expectedType);
-            // If this is a generic function and there is a signature tracker,
-            // make sure the signature is unique.
-            if (inferenceContext.signatureTracker && (0, types_1.isFunction)(typeResult.type)) {
-                typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, inferenceContext.signatureTracker, node.start);
-            }
-            if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
-                const diag = new diagnostic_1.DiagnosticAddendum();
-                // Make sure the resulting type is assignable to the expected type.
-                if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
-                    typeResult.typeErrors = true;
-                    typeResult.expectedTypeDiagAddendum = diag;
-                    diag.addTextRange(node);
-                }
-            }
-        }
-        if (printExpressionTypes) {
-            printExpressionSpaceCount--;
-            console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Post ${printType(typeResult.type)}${typeResult.isIncomplete ? ' Incomplete' : ''}`);
-        }
         return typeResult;
     }
     // Reports the case where a function or class has been decorated with
@@ -1536,7 +1540,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let callResult;
             useSpeculativeMode(callNode, () => {
                 callResult = validateFunctionArguments(exprNode, argList, { type }, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type)), 
-                /* skipUnknownArgCheck */ true);
+                /* skipUnknownArgCheck */ true, 
+                /* inferenceContext */ undefined, 
+                /* signatureTracker */ undefined);
             });
             signatures.push({
                 type: expandTypedKwargs(type),
@@ -2856,7 +2862,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 suppressDiagnostics(node.typeExpression, () => {
                                     callResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, node.typeExpression, [], concreteSubtype, 
                                     /* skipUnknownArgCheck */ false, 
-                                    /* inferenceContext */ undefined);
+                                    /* inferenceContext */ undefined, 
+                                    /* signatureTracker */ undefined);
                                 });
                                 if (callResult && callResult.argumentErrors) {
                                     diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
@@ -4210,7 +4217,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const callResult = suppressDiagnostics(errorNode, () => {
             return validateCallArguments(errorNode, argList, { type: methodType }, 
             /* typeVarContext */ undefined, 
-            /* skipUnknownArgCheck */ true);
+            /* skipUnknownArgCheck */ true, 
+            /* inferenceContext */ undefined, 
+            /* signatureTracker */ undefined);
         });
         // Collect deprecation information associated with the member access method.
         let deprecationInfo;
@@ -4407,7 +4416,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
         const callResult = validateCallArguments(errorNode, argList, { type: accessMemberType }, typeVarContext, 
-        /* skipUnknownArgCheck */ true);
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined, 
+        /* signatureTracker */ undefined);
         let isAsymmetricAccessor = false;
         if (usage.method === 'set') {
             isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
@@ -5209,7 +5220,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             useSpeculativeMode(node, () => {
                 callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ true);
+                /* skipUnknownArgCheck */ true, 
+                /* inferenceContext */ undefined, 
+                /* signatureTracker */ undefined);
                 if (callResult.argumentErrors) {
                     // If the object supports "__index__" magic method, convert
                     // the index to an int and try again.
@@ -5223,7 +5236,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 altArgList[0].typeResult = { type: intType };
                             }
                         }
-                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
+                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType }, 
+                        /* typeVarContext */ undefined, 
+                        /* skipUnknownArgCheck */ true, 
+                        /* inferenceContext */ undefined, 
+                        /* signatureTracker */ undefined);
                         // We were successful, so replace the arg list.
                         if (!callResult.argumentErrors) {
                             argList = altArgList;
@@ -5234,7 +5251,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
         /* typeVarContext */ undefined, 
-        /* skipUnknownArgCheck */ true);
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined, 
+        /* signatureTracker */ undefined);
         return {
             type: (_d = callResult.returnType) !== null && _d !== void 0 ? _d : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
@@ -5288,9 +5307,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
-        if ((options === null || options === void 0 ? void 0 : options.isFinalAnnotation) || (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation)) {
+        if (options === null || options === void 0 ? void 0 : options.isFinalAnnotation) {
             adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */ | 16 /* EvaluatorFlags.DisallowFinal */;
         }
+        else if (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation) {
+            adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */;
+            // If the annotation is a variable within the body of a dataclass, a
+            // Final is allowed within the ClassVar annotation. In all other cases,
+            // it's disallowed.
+            let disallowFinal = true;
+            const enclosingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopeAtFunction */ true);
+            if (enclosingClassNode) {
+                const classTypeInfo = getTypeOfClass(enclosingClassNode);
+                if (classTypeInfo && types_1.ClassType.isDataClass(classTypeInfo.classType)) {
+                    disallowFinal = false;
+                }
+            }
+            if (disallowFinal) {
+                adjFlags |= 16 /* EvaluatorFlags.DisallowFinal */;
+            }
+        }
         else {
             adjFlags &= ~(2 /* EvaluatorFlags.DoNotSpecialize */ |
                 32 /* EvaluatorFlags.DisallowParamSpec */ |
@@ -5425,7 +5461,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, flags, inferenceContext) {
+    function getTypeOfTuple(node, flags, inferenceContext, signatureTracker) {
         var _a;
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
@@ -5442,6 +5478,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
+        flags &= ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
+            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
+            128 /* EvaluatorFlags.ExpectingInstantiableType */);
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -5454,7 +5493,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (!matchingSubtype) {
                     const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
+                        return getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype), 
+                        /* signatureTracker */ undefined);
                     });
                     if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                         matchingSubtype = subtype;
@@ -5466,14 +5506,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, 
-            /* isTypeIncomplete */ false, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker));
+            const result = getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType), signatureTracker);
             if (result && !result.typeErrors) {
                 return result;
             }
             expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
-        const typeResult = getTypeOfTupleInferred(node);
+        const typeResult = getTypeOfTupleInferred(node, flags);
         // If there was an expected type of Any, replace the resulting type
         // with Any rather than return a type with unknowns.
         if (expectedTypeContainsAny) {
@@ -5481,7 +5520,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { ...typeResult, expectedTypeDiagAddendum };
     }
-    function getTypeOfTupleWithContext(node, inferenceContext) {
+    function getTypeOfTupleWithContext(node, flags, inferenceContext, signatureTracker) {
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
@@ -5519,10 +5558,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expectedTypes.push(homogenousType);
             }
         }
-        const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
-        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete, inferenceContext.signatureTracker)));
+        const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete), signatureTracker));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
         // Copy any expected type diag addenda for precision error reporting.
         let expectedTypeDiagAddendum;
         if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
@@ -5535,10 +5573,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type, expectedTypeDiagAddendum, isIncomplete };
     }
-    function getTypeOfTupleInferred(node) {
-        const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
+    function getTypeOfTupleInferred(node, flags) {
+        const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */) !== 0));
         if (isIncomplete) {
             if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
@@ -5546,7 +5584,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type, isIncomplete };
     }
-    function buildTupleTypesList(entryTypeResults) {
+    function buildTupleTypesList(entryTypeResults, stripLiterals) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
             let possibleUnpackedTuple;
@@ -5575,7 +5613,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 entryTypes.push({ type: types_1.UnknownType.create(/* isIncomplete */ true), isUnbounded: false });
             }
             else {
-                entryTypes.push({ type: typeResult.type, isUnbounded: !!typeResult.unpackedType });
+                const entryType = stripLiterals ? stripLiteralValue(typeResult.type) : typeResult.type;
+                entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
             }
         }
         // If there are multiple unbounded entries, combine all of them into a single
@@ -5588,7 +5627,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return entryTypes;
     }
-    function getTypeOfCall(node, flags, inferenceContext) {
+    function getTypeOfCall(node, flags, inferenceContext, signatureTracker) {
         var _a;
         let baseTypeResult;
         // Check for the use of `type(x)` within a type annotation. This isn't
@@ -5621,8 +5660,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the inference context has an associated signature tracker, make sure
         // the base type of this call is not the same as one of the tracked signatures.
         // This is important for nested generic calls (e.g. "foo(foo(x))").
-        if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) {
-            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, inferenceContext.signatureTracker, node.leftExpression.start);
+        if (signatureTracker) {
+            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, signatureTracker, node.leftExpression.start);
         }
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === 'super') {
@@ -5633,15 +5672,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                 node.leftExpression.value === 'reveal_type') {
                 // Handle the implicit "reveal_type" call.
-                typeResult = getTypeOfRevealType(node, inferenceContext);
+                typeResult = getTypeOfRevealType(node, inferenceContext, signatureTracker);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && baseTypeResult.type.details.builtInName === 'reveal_type') {
                 // Handle the "typing.reveal_type" call.
-                typeResult = getTypeOfRevealType(node, inferenceContext);
+                typeResult = getTypeOfRevealType(node, inferenceContext, signatureTracker);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && baseTypeResult.type.details.builtInName === 'assert_type') {
                 // Handle the "typing.assert_type" call.
-                typeResult = getTypeOfAssertType(node, inferenceContext);
+                typeResult = getTypeOfAssertType(node, inferenceContext, signatureTracker);
             }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
                 node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
@@ -5657,7 +5696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, inferenceContext);
+                /* skipUnknownArgCheck */ false, inferenceContext, signatureTracker);
                 typeResult.type = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 if (callResult.argumentErrors) {
                     typeResult.typeErrors = true;
@@ -5751,7 +5790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfAssertType(node, inferenceContext) {
+    function getTypeOfAssertType(node, inferenceContext, signatureTracker) {
         if (node.arguments.length !== 2 ||
             node.arguments[0].argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
             node.arguments[0].name !== undefined ||
@@ -5761,7 +5800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { type: types_1.UnknownType.create() };
         }
         const arg0TypeResult = getTypeOfExpression(node.arguments[0].valueExpression, 
-        /* flags */ undefined, inferenceContext);
+        /* flags */ undefined, inferenceContext, signatureTracker);
         if (arg0TypeResult.isIncomplete) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
@@ -5775,7 +5814,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: arg0TypeResult.type };
     }
-    function getTypeOfRevealType(node, inferenceContext) {
+    function getTypeOfRevealType(node, inferenceContext, signatureTracker) {
         let arg0Value;
         let expectedRevealTypeNode;
         let expectedRevealType;
@@ -5812,7 +5851,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addError(localize_1.LocMessage.revealTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext);
+        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext, signatureTracker);
         const type = typeResult.type;
         const exprString = ParseTreeUtils.printExpression(arg0Value);
         const typeString = printType(type, { expandTypeAlias: true });
@@ -6095,7 +6134,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // there will be only one argument list in expandedArgTypes, and all entries
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
-    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
         var _a, _b;
         const returnTypes = [];
         const matchedOverloads = [];
@@ -6131,7 +6170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
                     return validateFunctionArgumentTypesWithContext(errorNode, matchResults, effectiveTypeVarContext, 
-                    /* skipUnknownArgCheck */ true, inferenceContext);
+                    /* skipUnknownArgCheck */ true, inferenceContext, signatureTracker);
                 });
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
@@ -6240,7 +6279,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
         finalTypeVarContext.unlock();
         finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateFunctionArgumentTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const finalCallResult = validateFunctionArgumentTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -6306,7 +6345,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Create a list of potential overload matches based on arguments.
         types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
-                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex, 
+                /* signatureTracker */ undefined);
                 if (!matchResults.argumentErrors) {
                     matches.push(matchResults);
                 }
@@ -6337,7 +6377,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return a.overloadIndex - b.overloadIndex;
         });
     }
-    function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
@@ -6352,7 +6392,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
-                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex, signatureTracker);
                 if (!matchResults.argumentErrors) {
                     filteredMatchResults.push(matchResults);
                 }
@@ -6369,7 +6409,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const functionName = typeResult.type.overloads[0].details.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => {
-                    const typeString = printType(getTypeOfArgument(t).type);
+                    const typeString = printType(getTypeOfArgument(t, /* inferenceContext */ undefined, signatureTracker).type);
                     if (t.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                         return `*${typeString}`;
                     }
@@ -6408,7 +6448,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(bestMatch.overload));
             effectiveTypeVarContext.unlock();
-            return validateFunctionArgumentTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            return validateFunctionArgumentTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
         }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
@@ -6420,7 +6460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         while (true) {
-            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
             if (callResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
             }
@@ -6518,7 +6558,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
     // the way, it emits a diagnostic and sets argumentErrors to true.
-    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext, recursionCount = 0) {
+    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount = 0) {
         let argumentErrors = false;
         let isTypeIncomplete = false;
         let specializedInitSelfType;
@@ -6537,7 +6577,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
             return useSpeculativeMode(isLastIteration ? undefined : errorNode, () => {
-                const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
                 if (callResult.argumentErrors) {
                     argumentErrors = true;
                 }
@@ -6567,7 +6607,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             overloadsUsedForCall,
         };
     }
-    function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+    function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount) {
         switch (expandedCallType.category) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
@@ -6578,17 +6618,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!isCallTypeIncomplete) {
                     argList.forEach((arg) => {
                         if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                            getTypeOfArgument(arg);
+                            getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker);
                         }
                     });
                 }
                 return { returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
-                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
             }
             case 5 /* TypeCategory.OverloadedFunction */: {
-                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
             }
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
@@ -6596,16 +6636,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { argumentErrors: true };
                 }
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
-                    return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext);
+                    return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
                 }
-                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
             }
             // TypeVars should have been expanded in most cases,
             // but we still need to handle the case of Type[T] where
             // T is a constrained type that contains a union. We also
             // need to handle recursive type aliases.
             case 9 /* TypeCategory.TypeVar */: {
-                return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
             }
             case 7 /* TypeCategory.Module */: {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
@@ -6614,7 +6654,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { argumentErrors: true };
     }
-    function validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
         var _a;
         if (types_1.TypeBase.isInstantiable(expandedCallType)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
@@ -6634,14 +6674,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
-            validateFunctionArguments(errorNode, argList, { type: expandedCallType }, effectiveTypeVarContext, skipUnknownArgCheck);
+            validateFunctionArguments(errorNode, argList, { type: expandedCallType }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
             return result;
         }
         // Handle the NewType specially, replacing the normal return type.
         if (expandedCallType.details.builtInName === 'NewType') {
             return { returnType: createNewType(errorNode, argList) };
         }
-        const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
         let isTypeIncomplete = !!functionResult.isTypeIncomplete;
         let returnType = functionResult.returnType;
         let argumentErrors = !!functionResult.argumentErrors;
@@ -6748,13 +6788,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { symbol, symbolName, classType, hasImplementation };
     }
-    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
         var _a, _b;
         // Handle the 'cast' call as a special case.
         if (expandedCallType.overloads[0].details.builtInName === 'cast' && argList.length === 2) {
             return { returnType: evaluateCastCall(argList, errorNode) };
         }
-        const callResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        const callResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         let isTypeIncomplete = !!callResult.isTypeIncomplete;
         let argumentErrors = !!callResult.argumentErrors;
@@ -6781,7 +6821,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             specializedInitSelfType: callResult.specializedInitSelfType,
         };
     }
-    function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker) {
         var _a, _b;
         if (expandedCallType.literalValue !== undefined) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.literalNotCallable(), errorNode);
@@ -6798,11 +6838,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { returnType: types_1.UnknownType.create(), argumentErrors: true };
                 }
                 // Validate the constructor arguments.
-                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
+                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
                 // The one-parameter form of "type" returns the class
                 // for the specified object.
                 if (expandedCallType.details.name === 'type' && argList.length === 1) {
-                    const argType = getTypeOfArgument(argList[0]).type;
+                    const argType = getTypeOfArgument(argList[0], 
+                    /* inferenceContext */ undefined, signatureTracker).type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
                         if ((0, types_1.isInstantiableClass)(subtype) && subtype.details.effectiveMetaclass) {
                             return subtype.details.effectiveMetaclass;
@@ -6864,7 +6905,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
-                    /* inferenceContext */ undefined);
+                    /* inferenceContext */ undefined, signatureTracker);
                 }
                 return result;
             }
@@ -6926,7 +6967,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }), errorNode);
         }
         // Assume this is a call to the constructor.
-        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
+        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
         const overloadsUsedForCall = constructorResult.overloadsUsedForCall;
         const argumentErrors = constructorResult.argumentErrors;
         const isTypeIncomplete = constructorResult.isTypeIncomplete;
@@ -6945,7 +6986,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             returnType.details.mro.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'type'))) {
             let newClassName = '__class_' + returnType.details.name;
             if (argList.length === 3) {
-                const firstArgType = getTypeOfArgument(argList[0]).type;
+                const firstArgType = getTypeOfArgument(argList[0], 
+                /* inferenceContext */ undefined, signatureTracker).type;
                 if ((0, types_1.isClassInstance)(firstArgType) &&
                     types_1.ClassType.isBuiltIn(firstArgType, 'str') &&
                     typeof firstArgType.literalValue === 'string') {
@@ -6961,7 +7003,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
     }
-    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount) {
         var _a;
         const callDiag = new diagnostic_1.DiagnosticAddendum();
         const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
@@ -6974,7 +7016,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }) + callDiag.getString(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
-        const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+        const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         if ((0, types_1.isTypeVar)(unexpandedCallType) &&
             types_1.TypeBase.isInstantiable(unexpandedCallType) &&
@@ -6994,7 +7036,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function evaluateCastCall(argList, errorNode) {
         // Verify that the cast is necessary.
         const castToType = getTypeOfArgumentExpectingType(argList[0], { enforceTypeAnnotationRules: true }).type;
-        let castFromType = getTypeOfArgument(argList[1]).type;
+        let castFromType = getTypeOfArgument(argList[1], 
+        /* inferenceContext */ undefined, 
+        /* signatureTracker */ undefined).type;
         if (castFromType.specialForm) {
             castFromType = castFromType.specialForm;
         }
@@ -7010,12 +7054,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return (0, typeUtils_1.convertToInstance)(castToType);
     }
     // Expands any unpacked tuples within an argument list.
-    function expandArgList(argList) {
+    function expandArgList(argList, signatureTracker) {
         var _a;
         const expandedArgList = [];
         for (const arg of argList) {
             if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
-                const argType = getTypeOfArgument(arg).type;
+                const argType = getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker).type;
                 // If this is a tuple with specified element types, use those
                 // specified types rather than using the more generic iterator
                 // type which will be a union of all element types.
@@ -7057,7 +7101,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // function. This matching is done based on positions and keywords. Type evaluation and
     // 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) {
+    function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex, signatureTracker) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
@@ -7066,7 +7110,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isVariadicTypeVarFullyMatched = false;
         // Expand any unpacked tuples in the arg list.
-        argList = expandArgList(argList);
+        argList = expandArgList(argList, signatureTracker);
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
@@ -7076,7 +7120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 paramMap.set(param.name, {
                     argsNeeded: param.category === 0 /* ParameterCategory.Simple */ && !param.hasDefault ? 1 : 0,
                     argsReceived: 0,
-                    isPositionalOnly: paramInfo.source === parameterUtils_1.ParameterSource.PositionOnly,
+                    isPositionalOnly: paramInfo.kind === parameterUtils_1.ParameterKind.Positional,
                 });
             }
         });
@@ -7190,7 +7234,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // If this is an unpacked iterable, we will conservatively assume that it
                         // might have zero iterations unless we can tell from its type that it
                         // definitely has at least one iterable value.
-                        const argType = getTypeOfArgument(argList[argIndex]).type;
+                        const argType = getTypeOfArgument(argList[argIndex], 
+                        /* inferenceContext */ undefined, signatureTracker).type;
                         if ((0, types_1.isClassInstance)(argType) &&
                             (0, typeUtils_1.isTupleClass)(argType) &&
                             !(0, typeUtils_1.isUnboundedTupleClass)(argType) &&
@@ -7225,7 +7270,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
-                const argTypeResult = getTypeOfArgument(argList[argIndex]);
+                const argTypeResult = getTypeOfArgument(argList[argIndex], 
+                /* inferenceContext */ undefined, signatureTracker);
                 let listElementType;
                 let advanceToNextArg = false;
                 // Handle the case where *args is being passed to a function defined
@@ -7460,7 +7506,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType)).type;
+                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker).type;
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
                     }
@@ -7675,7 +7721,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // Handle the case where a *args: P.args (or *args: Any) is passed as an
                         // argument to a function that accepts a ParamSpec.
                         if (typeResult.type.details.paramSpec) {
-                            const argTypeResult = getTypeOfArgument(argList[argIndex]);
+                            const argTypeResult = getTypeOfArgument(argList[argIndex], 
+                            /* inferenceContext */ undefined, signatureTracker);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
                                 isTypeIncomplete = true;
@@ -7798,7 +7845,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isVariadicTypeVar)(paramType) && !paramType.isVariadicInUnion) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
-                        const argType = getTypeOfArgument(argParam.argument).type;
+                        const argType = getTypeOfArgument(argParam.argument, 
+                        /* inferenceContext */ undefined, signatureTracker).type;
                         const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
                             ((0, types_1.isClassInstance)(argType) &&
                                 (0, typeUtils_1.isTupleClass)(argType) &&
@@ -7878,10 +7926,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
-        var _a, _b;
+    function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext, signatureTracker) {
+        var _a;
         const type = matchResults.overload;
-        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        if (!signatureTracker) {
+            signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        }
         matchResults.overload = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(matchResults.overload, signatureTracker, errorNode.start);
         // Can we safely ignore the inference context (either because it's not provided
         // or will have no effect)? If so, we can eliminate a bunch of extra work.
@@ -7889,7 +7939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
-            !(0, typeUtils_1.requiresSpecialization)((_b = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create())) {
+            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
             return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
@@ -7972,7 +8022,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
     }
-    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck = false) {
+    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
@@ -8289,11 +8339,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Tries to assign the call arguments to the function parameter
     // 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();
+    function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext, signatureTracker) {
+        if (!signatureTracker) {
+            signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        }
         typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, errorNode.start);
-        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
+        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0, signatureTracker);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
@@ -8308,7 +8359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 overloadsUsedForCall: [],
             };
         }
-        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));
+        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.
@@ -8344,7 +8395,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!paramSpecType) {
             paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpec);
         }
-        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: paramSpecType }, 0);
+        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: paramSpecType }, 0, signatureTracker);
         const functionType = matchResults.overload;
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
         if (matchResults.argumentErrors) {
@@ -8369,7 +8420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let argumentErrors = false;
             let argErrorNode;
             for (const arg of argList) {
-                const argType = (_a = getTypeOfArgument(arg)) === null || _a === void 0 ? void 0 : _a.type;
+                const argType = (_a = getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker)) === null || _a === void 0 ? void 0 : _a.type;
                 const isArgTypeCompatible = argType && ((0, types_1.isTypeSame)(argType, paramSpec, { ignoreTypeFlags: true }) || (0, types_1.isAnyOrUnknown)(argType));
                 if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */ && !sawArgs && isArgTypeCompatible) {
                     sawArgs = true;
@@ -8394,7 +8445,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { argumentErrors, typeVarContexts: [srcTypeVarContext] };
         }
-        const result = validateFunctionArgumentTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker);
+        const result = validateFunctionArgumentTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker, 
+        /* skipUnknownArgCheck */ undefined);
         return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
     }
     function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
@@ -8457,7 +8509,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         16 /* EvaluatorFlags.DisallowFinal */ |
                         2 /* EvaluatorFlags.DoNotSpecialize */
                     : 2 /* EvaluatorFlags.DoNotSpecialize */ | 16 /* EvaluatorFlags.DisallowFinal */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
+                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
                 // signature, force the type arguments for the duplicates to have
@@ -8492,7 +8544,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 argType = argParam.argType;
             }
             else {
-                const argTypeResult = getTypeOfArgument(argParam.argument);
+                const argTypeResult = getTypeOfArgument(argParam.argument, 
+                /* inferenceContext */ undefined, signatureTracker);
                 argType = argTypeResult.type;
                 if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
@@ -9190,12 +9243,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createClassFromMetaclass(errorNode, argList, metaclass) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-        const arg0Type = getTypeOfArgument(argList[0]).type;
+        const arg0Type = getTypeOfArgument(argList[0], 
+        /* inferenceContext */ undefined, 
+        /* signatureTracker */ undefined).type;
         if (!(0, types_1.isClassInstance)(arg0Type) || !types_1.ClassType.isBuiltIn(arg0Type, 'str')) {
             return undefined;
         }
         const className = arg0Type.literalValue || '_';
-        const arg1Type = getTypeOfArgument(argList[1]).type;
+        const arg1Type = getTypeOfArgument(argList[1], 
+        /* inferenceContext */ undefined, 
+        /* signatureTracker */ undefined).type;
         // TODO - properly handle case where tuple of base classes is provided.
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
@@ -9258,7 +9315,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, debug_1.assert)(magicMethodType !== undefined);
                     return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                     /* typeVarContext */ undefined, 
-                    /* skipUnknownArgCheck */ true, inferenceContext);
+                    /* skipUnknownArgCheck */ true, inferenceContext, 
+                    /* signatureTracker */ undefined);
                 });
                 // If there were errors with the expected type, try
                 // to evaluate without the expected type.
@@ -9267,7 +9325,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         (0, debug_1.assert)(magicMethodType !== undefined);
                         return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                         /* typeVarContext */ undefined, 
-                        /* skipUnknownArgCheck */ true);
+                        /* skipUnknownArgCheck */ true, 
+                        /* inferenceContext */ undefined, 
+                        /* signatureTracker */ undefined);
                     });
                 }
                 if (callResult.argumentErrors) {
@@ -9325,7 +9385,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
+                    return getTypeOfDictionaryWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -9342,15 +9402,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let expectedTypeDiagAddendum = undefined;
         if (effectiveExpectedType) {
             expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType), expectedTypeDiagAddendum);
+            const result = getTypeOfDictionaryWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType), expectedTypeDiagAddendum);
             if (result) {
                 return result;
             }
         }
-        const result = getTypeOfDictionaryInferred(node, /* hasExpectedType */ !!inferenceContext);
+        const result = getTypeOfDictionaryInferred(node, flags, /* hasExpectedType */ !!inferenceContext);
         return { ...result, expectedTypeDiagAddendum };
     }
-    function getTypeOfDictionaryWithContext(node, inferenceContext, expectedDiagAddendum) {
+    function getTypeOfDictionaryWithContext(node, flags, inferenceContext, expectedDiagAddendum) {
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         let concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
         if (!(0, types_1.isClassInstance)(concreteExpectedType)) {
@@ -9367,7 +9427,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             concreteExpectedType = types_1.TypeBase.cloneForCondition(concreteExpectedType, undefined);
             const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
             // Infer the key and value types if possible.
-            const keyValueTypeResult = getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
+            const keyValueTypeResult = getKeyAndValueTypesFromDictionary(node, flags, keyTypes, valueTypes, 
             /* forceStrictInference */ true, 
             /* isValueTypeInvariant */ true, 
             /* expectedKeyType */ undefined, 
@@ -9425,7 +9485,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Infer the key and value types if possible.
-        const keyValueResult = getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
+        const keyValueResult = getKeyAndValueTypesFromDictionary(node, flags, keyTypes, valueTypes, 
         /* forceStrictInference */ true, isValueTypeInvariant, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum);
         if (keyValueResult.isIncomplete) {
             isIncomplete = true;
@@ -9444,7 +9504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Attempts to infer the type of a dictionary statement. If hasExpectedType
     // is true, strict inference is used for the subexpressions.
-    function getTypeOfDictionaryInferred(node, hasExpectedType) {
+    function getTypeOfDictionaryInferred(node, flags, hasExpectedType) {
         const fallbackType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         let keyType = fallbackType;
         let valueType = fallbackType;
@@ -9454,7 +9514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let isIncomplete = false;
         let typeErrors = false;
         // Infer the key and value types if possible.
-        const keyValueResult = getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
+        const keyValueResult = getKeyAndValueTypesFromDictionary(node, flags, keyTypeResults, valueTypeResults, 
         /* forceStrictInference */ hasExpectedType, 
         /* isValueTypeInvariant */ false);
         if (keyValueResult.isIncomplete) {
@@ -9498,16 +9558,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type, isIncomplete, typeErrors };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, isValueTypeInvariant, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
+    function getKeyAndValueTypesFromDictionary(node, flags, keyTypes, valueTypes, forceStrictInference, isValueTypeInvariant, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
         let typeErrors = false;
+        // Mask out some of the flags that are not applicable for a dictionary key
+        // even if it appears within an inlined TypedDict annotation.
+        const keyFlags = flags &
+            ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
+                8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
+                128 /* EvaluatorFlags.ExpectingInstantiableType */);
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
             var _a, _b, _c, _d;
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
-                const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
+                const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, keyFlags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9530,14 +9595,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     expectedTypedDictEntries.knownItems.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.knownItems.get(keyType.literalValue).valueType;
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
-                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, entryInferenceContext);
+                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
-                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, entryInferenceContext);
+                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
                 }
                 if (entryInferenceContext && !valueTypeResult.typeErrors) {
                     const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !isValueTypeInvariant);
@@ -9579,8 +9642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
-                let unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, entryInferenceContext);
+                let unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
                 if (entryInferenceContext && !unexpandedTypeResult.typeErrors) {
                     const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !isValueTypeInvariant);
                     if (fromExpectedType) {
@@ -9645,7 +9707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (entryNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
-                const dictEntryTypeResult = getElementTypeFromListComprehension(entryNode, expectedValueType, expectedKeyType);
+                const dictEntryTypeResult = getElementTypeFromListComprehension(entryNode, flags, expectedValueType, expectedKeyType);
                 const dictEntryType = dictEntryTypeResult.type;
                 if (dictEntryTypeResult.isIncomplete) {
                     isIncomplete = true;
@@ -9683,6 +9745,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             diag.addMessage(localize_1.LocAddendum.useListInstead());
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
         }
+        flags &= ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
+            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
+            128 /* EvaluatorFlags.ExpectingInstantiableType */);
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -9695,7 +9760,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
+                    return getTypeOfListOrSetWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -9711,18 +9776,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
+            const result = getTypeOfListOrSetWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
             expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
-        const typeResult = getTypeOfListOrSetInferred(node, /* hasExpectedType */ inferenceContext !== undefined);
+        const typeResult = getTypeOfListOrSetInferred(node, flags, 
+        /* hasExpectedType */ inferenceContext !== undefined);
         return { ...typeResult, expectedTypeDiagAddendum };
     }
     // Attempts to determine the type of a list or set statement based on an expected type.
     // Returns undefined if that type cannot be honored.
-    function getTypeOfListOrSetWithContext(node, inferenceContext) {
+    function getTypeOfListOrSetWithContext(node, flags, inferenceContext) {
         const builtInClassName = node.nodeType === 31 /* ParseNodeType.List */ ? 'list' : 'set';
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         let isIncomplete = false;
@@ -9737,11 +9803,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         node.entries.forEach((entry) => {
             let entryTypeResult;
             if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */) {
-                entryTypeResult = getElementTypeFromListComprehension(entry, expectedEntryType);
+                entryTypeResult = getElementTypeFromListComprehension(entry, flags, expectedEntryType);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
             }
             entryTypes.push(entryTypeResult.type);
             if (entryTypeResult.isIncomplete) {
@@ -9795,7 +9860,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return specializedListOrSet.typeArguments[0];
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
-    function getTypeOfListOrSetInferred(node, hasExpectedType) {
+    function getTypeOfListOrSetInferred(node, flags, hasExpectedType) {
         const builtInClassName = node.nodeType === 31 /* ParseNodeType.List */ ? 'list' : 'set';
         const verifyHashable = node.nodeType === 45 /* ParseNodeType.Set */;
         let isEmptyContainer = false;
@@ -9805,10 +9870,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         node.entries.forEach((entry, index) => {
             let entryTypeResult;
             if (entry.nodeType === 32 /* ParseNodeType.ListComprehension */ && !entry.isGenerator) {
-                entryTypeResult = getElementTypeFromListComprehension(entry);
+                entryTypeResult = getElementTypeFromListComprehension(entry, flags);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry);
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */);
             }
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -10124,7 +10189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: functionType, isIncomplete, typeErrors };
     }
-    function getTypeOfListComprehension(node, inferenceContext) {
+    function getTypeOfListComprehension(node, flags, inferenceContext) {
         let isIncomplete = false;
         let typeErrors = false;
         // If any of the "for" clauses are marked async or any of the "if" clauses
@@ -10142,7 +10207,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
-        const elementTypeResult = getElementTypeFromListComprehension(node, expectedEntryType);
+        const elementTypeResult = getElementTypeFromListComprehension(node, flags, expectedEntryType);
         if (elementTypeResult.isIncomplete) {
             isIncomplete = true;
         }
@@ -10212,7 +10277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Returns the type of one entry returned by the list comprehension,
     // as opposed to the entire list.
-    function getElementTypeFromListComprehension(node, expectedValueOrElementType, expectedKeyType) {
+    function getElementTypeFromListComprehension(node, flags, expectedValueOrElementType, expectedKeyType) {
         let isIncomplete = false;
         let typeErrors = false;
         // "Execute" the list comprehensions from start to finish.
@@ -10224,8 +10289,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let type = types_1.UnknownType.create();
         if (node.expression.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
             // Create a tuple with the key/value types.
-            const keyTypeResult = getTypeOfExpression(node.expression.keyExpression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
+            const keyTypeResult = getTypeOfExpression(node.expression.keyExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
             if (keyTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10236,8 +10300,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!expectedKeyType || !(0, typeUtils_1.containsLiteralType)(expectedKeyType)) {
                 keyType = stripLiteralValue(keyType);
             }
-            const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (valueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10255,12 +10318,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else if (node.expression.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
             // The parser should have reported an error in this case because it's not allowed.
-            getTypeOfExpression(node.expression.expandExpression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            getTypeOfExpression(node.expression.expandExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
         }
         else if ((0, parseNodes_1.isExpressionNode)(node)) {
-            const exprTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
+            const exprTypeResult = getTypeOfExpression(node.expression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (exprTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -12448,7 +12509,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (initSubclassMethodType && initSubclassMethodInfo.classType) {
                     const callResult = validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
                     /* typeVarContext */ undefined, 
-                    /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
+                    /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()), 
+                    /* signatureTracker */ undefined);
                     if (callResult.argumentErrors) {
                         const diag = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initSubclassCallFailed(), node.name);
                         const initSubclassFunction = (0, types_1.isOverloadedFunction)(initSubclassMethodType)
@@ -14547,9 +14609,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         return { type: specializedClass };
     }
-    function getTypeOfArgument(arg, inferenceContext) {
+    function getTypeOfArgument(arg, inferenceContext, signatureTracker) {
+        var _a, _b;
         if (arg.typeResult) {
-            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
+            const type = (_b = (_a = arg.typeResult.type) === null || _a === void 0 ? void 0 : _a.specialForm) !== null && _b !== void 0 ? _b : arg.typeResult.type;
+            return { type, isIncomplete: arg.typeResult.isIncomplete };
         }
         if (!arg.valueExpression) {
             // We shouldn't ever get here, but just in case.
@@ -14557,7 +14621,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // 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, /* flags */ undefined, inferenceContext);
+        const typeResult = getTypeOfExpression(arg.valueExpression, 
+        /* flags */ undefined, inferenceContext, signatureTracker);
+        if (signatureTracker) {
+            typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, arg.valueExpression.start);
+        }
+        return typeResult;
     }
     // This function is like getTypeOfArgument except that it is
     // used in cases where the argument is expected to be a type
@@ -15832,7 +15901,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getFunctionEffectiveReturnType(type, callSiteInfo, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            return adjustCallableReturnType(type, specializedReturnType, /* liveTypeVarScopes */ []);
+            const liveTypeVarScopes = (callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
+                ? ParseTreeUtils.getTypeVarScopesForNode(callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
+                : [];
+            return adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
         }
         if (inferTypeIfNeeded) {
             return getFunctionInferredReturnType(type, callSiteInfo);
@@ -16224,24 +16296,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return true;
             }
         }
-        const destErrorType = reportErrorsUsingObjType ? types_1.ClassType.cloneAsInstance(destType) : destType;
-        const srcErrorType = reportErrorsUsingObjType ? types_1.ClassType.cloneAsInstance(srcType) : srcType;
-        let destErrorTypeText = printType(destErrorType);
-        let srcErrorTypeText = printType(srcErrorType);
-        // If the text is the same, use the fully-qualified name rather than the short name.
-        if (destErrorTypeText === srcErrorTypeText && destType.details.fullName && srcType.details.fullName) {
-            destErrorTypeText = destType.details.fullName;
-            srcErrorTypeText = srcType.details.fullName;
-        }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
-            sourceType: srcErrorTypeText,
-            destType: destErrorTypeText,
-        }));
-        // Tell the user about the disableBytesTypePromotions if that is involved.
-        if (types_1.ClassType.isBuiltIn(destType, 'bytes')) {
-            const promotions = typePromotions.get(destType.details.fullName);
-            if (promotions && promotions.some((name) => name === srcType.details.fullName)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.bytesTypePromotions());
+        if (diag) {
+            const destErrorType = reportErrorsUsingObjType ? types_1.ClassType.cloneAsInstance(destType) : destType;
+            const srcErrorType = reportErrorsUsingObjType ? types_1.ClassType.cloneAsInstance(srcType) : srcType;
+            let destErrorTypeText = printType(destErrorType);
+            let srcErrorTypeText = printType(srcErrorType);
+            // If the text is the same, use the fully-qualified name rather than the short name.
+            if (destErrorTypeText === srcErrorTypeText && destType.details.fullName && srcType.details.fullName) {
+                destErrorTypeText = destType.details.fullName;
+                srcErrorTypeText = srcType.details.fullName;
+            }
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
+                sourceType: srcErrorTypeText,
+                destType: destErrorTypeText,
+            }));
+            // Tell the user about the disableBytesTypePromotions if that is involved.
+            if (types_1.ClassType.isBuiltIn(destType, 'bytes')) {
+                const promotions = typePromotions.get(destType.details.fullName);
+                if (promotions && promotions.some((name) => name === srcType.details.fullName)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.bytesTypePromotions());
+                }
             }
         }
         return false;
@@ -17058,9 +17132,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.ClassType.isBuiltIn(destType, 'type') && ((_c = srcType.instantiableNestingLevel) !== null && _c !== void 0 ? _c : 0) > 0) {
                     return true;
                 }
-                if (!isSpecialFormClass(expandedSrcType, flags) &&
-                    assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
-                    /* reportErrorsUsingObjType */ false)) {
+                if (isSpecialFormClass(expandedSrcType, flags)) {
+                    if (destType.specialForm) {
+                        return assignType(destType.specialForm, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    }
+                }
+                else if (assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -17818,7 +17896,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let srcLastToPackIndex = srcDetails.params.findIndex((p, i) => {
             (0, debug_1.assert)(destDetails.argsIndex !== undefined);
-            return i >= destDetails.argsIndex && p.source === parameterUtils_1.ParameterSource.KeywordOnly;
+            return i >= destDetails.argsIndex && p.kind === parameterUtils_1.ParameterKind.Keyword;
         });
         if (srcLastToPackIndex < 0) {
             srcLastToPackIndex = srcDetails.params.length;
@@ -17866,7 +17944,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     },
                     type: srcPositionalsType,
                     index: -1,
-                    source: parameterUtils_1.ParameterSource.PositionOnly,
+                    kind: parameterUtils_1.ParameterKind.Positional,
                 },
                 ...srcDetails.params.slice(destDetails.argsIndex + srcPositionalsToPack.length, srcDetails.params.length),
             ];
@@ -17874,15 +17952,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcDetails.argsIndex = argsIndex >= 0 ? argsIndex : undefined;
             const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* ParameterCategory.KwargsDict */);
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
-            const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === parameterUtils_1.ParameterSource.KeywordOnly);
+            const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.kind === parameterUtils_1.ParameterKind.Keyword);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
-            srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.source !== parameterUtils_1.ParameterSource.PositionOnly ||
+            srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.kind !== parameterUtils_1.ParameterKind.Positional ||
                 p.param.category !== 0 /* ParameterCategory.Simple */ ||
                 p.param.hasDefault));
         }
     }
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
@@ -17918,11 +17996,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
             const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
             if (destParamName) {
-                const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
+                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParameterKind.Positional;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* ParameterCategory.ArgsList */ &&
                     srcParam.param.category !== 1 /* ParameterCategory.ArgsList */) {
-                    if (srcParam.source === parameterUtils_1.ParameterSource.PositionOnly) {
+                    if (srcParam.kind === parameterUtils_1.ParameterKind.Positional) {
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                             name: destParamName,
                         }));
@@ -17968,10 +18046,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     canAssign = false;
                 }
             }
-            else if (destParam.source !== parameterUtils_1.ParameterSource.PositionOnly &&
-                srcParam.source === parameterUtils_1.ParameterSource.PositionOnly &&
+            else if (destParam.kind !== parameterUtils_1.ParameterKind.Positional &&
+                srcParam.kind === parameterUtils_1.ParameterKind.Positional &&
                 srcParamDetails.kwargsIndex === undefined &&
-                !srcParamDetails.params.some((p) => p.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParameterKind.Keyword &&
                     p.param.category === 0 /* ParameterCategory.Simple */ &&
                     p.param.name === destParam.param.name)) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
@@ -17989,36 +18067,50 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }));
             canAssign = false;
         }
-        if (destPositionalCount < srcPositionalCount) {
-            // If the dest type includes a ParamSpec, the additional parameters
-            // can be assigned to it, so no need to report an error here.
-            if (!targetIncludesParamSpec) {
-                const nonDefaultSrcParamCount = srcParamDetails.params.filter((p) => !!p.param.name && !p.param.hasDefault && p.param.category === 0 /* ParameterCategory.Simple */).length;
-                if (destParamDetails.argsIndex === undefined) {
-                    if (destPositionalCount < nonDefaultSrcParamCount) {
-                        if (destParamDetails.firstPositionOrKeywordIndex > 0 &&
-                            destParamDetails.firstPositionOrKeywordIndex < srcPositionalCount) {
-                            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionTooFewParams().format({
-                                expected: nonDefaultSrcParamCount,
-                                received: destPositionalCount,
-                            }));
-                            canAssign = false;
-                        }
+        if (destPositionalCount < srcPositionalCount && !targetIncludesParamSpec) {
+            for (let i = destPositionalCount; i < srcPositionalCount; i++) {
+                // If the dest has an *args parameter, make sure it can accept the remaining
+                // positional arguments in the source.
+                if (destParamDetails.argsIndex !== undefined) {
+                    const destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
+                    const srcParamType = srcParamDetails.params[i].type;
+                    if (!assignFunctionParameter(destArgsType, srcParamType, i, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        canAssign = false;
                     }
+                    continue;
                 }
-                else {
-                    // Make sure the remaining positional arguments are of the
-                    // correct type for the *args parameter.
-                    const destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
-                    if (!(0, types_1.isAnyOrUnknown)(destArgsType)) {
-                        for (let paramIndex = destPositionalCount; paramIndex < srcPositionalCount; paramIndex++) {
-                            const srcParamType = srcParamDetails.params[paramIndex].type;
-                            if (!assignFunctionParameter(destArgsType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                                canAssign = false;
-                            }
-                        }
+                // If The source parameter has a default value, it is OK for the
+                // corresponding dest parameter to be missing.
+                const srcParam = srcParamDetails.params[i];
+                if (srcParam.param.hasDefault) {
+                    // Assign default arg value in case it is needed for
+                    // populating TypeVar constraints.
+                    const paramInfo = srcParamDetails.params[i];
+                    const defaultArgType = (_f = paramInfo.defaultArgType) !== null && _f !== void 0 ? _f : paramInfo.param.defaultType;
+                    if (defaultArgType &&
+                        !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, 
+                        /* destTypeVarContext */ undefined, flags, recursionCount)) {
+                        canAssign = false;
                     }
+                    continue;
+                }
+                // If the source parameter is also addressible by keyword, it is OK
+                // that there is no matching positional parameter in the dest.
+                if (srcParam.kind === parameterUtils_1.ParameterKind.Standard) {
+                    continue;
+                }
+                // If the source parameter is a variadic, it is OK that there is no
+                // matching positional parameter in the dest.
+                if (srcParam.param.category === 1 /* ParameterCategory.ArgsList */) {
+                    continue;
                 }
+                const nonDefaultSrcParamCount = srcParamDetails.params.filter((p) => !!p.param.name && !p.param.hasDefault && p.param.category === 0 /* ParameterCategory.Simple */).length;
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionTooFewParams().format({
+                    expected: nonDefaultSrcParamCount,
+                    received: destPositionalCount,
+                }));
+                canAssign = false;
+                break;
             }
         }
         else if (srcPositionalCount < destPositionalCount) {
@@ -18039,10 +18131,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!assignFunctionParameter(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                             canAssign = false;
                         }
-                        if (destParamDetails.params[paramIndex].source !== parameterUtils_1.ParameterSource.PositionOnly &&
+                        if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParameterKind.Positional &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                                name: (_f = destParamDetails.params[paramIndex].param.name) !== null && _f !== void 0 ? _f : '',
+                                name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : '',
                             }));
                             canAssign = false;
                         }
@@ -18090,7 +18182,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destParamDetails.argsIndex !== undefined &&
             !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsParamMissing().format({
-                paramName: (_g = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _g !== void 0 ? _g : '',
+                paramName: (_h = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _h !== void 0 ? _h : '',
             }));
             canAssign = false;
         }
@@ -18117,16 +18209,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if (srcStartOfNamed >= 0) {
                 srcParamDetails.params.forEach((srcParamInfo, index) => {
+                    var _a;
                     if (index >= srcStartOfNamed) {
                         if (srcParamInfo.param.name &&
                             srcParamInfo.param.category === 0 /* ParameterCategory.Simple */ &&
-                            srcParamInfo.source !== parameterUtils_1.ParameterSource.PositionOnly) {
+                            srcParamInfo.kind !== parameterUtils_1.ParameterKind.Positional) {
                             const destParamInfo = destParamMap.get(srcParamInfo.param.name);
                             const paramDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                             const srcParamType = srcParamInfo.type;
                             if (!destParamInfo) {
                                 if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.param.hasDefault) {
-                                    if (paramDiag && srcParamDetails.firstKeywordOnlyIndex !== undefined) {
+                                    if (paramDiag) {
                                         paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
                                             name: srcParamInfo.param.name,
                                         }));
@@ -18139,6 +18232,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                         canAssign = false;
                                     }
                                 }
+                                else if (srcParamInfo.param.hasDefault) {
+                                    // Assign default arg values in case they are needed for
+                                    // populating TypeVar constraints.
+                                    const defaultArgType = (_a = srcParamInfo.defaultArgType) !== null && _a !== void 0 ? _a : srcParamInfo.param.defaultType;
+                                    if (defaultArgType &&
+                                        !assignType(srcParamInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, 
+                                        /* destTypeVarContext */ undefined, flags, recursionCount)) {
+                                        canAssign = false;
+                                    }
+                                }
                             }
                             else {
                                 const destParamType = destParamInfo.type;
@@ -18203,7 +18306,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the source and the dest are using the same ParamSpec, any additional
         // concatenated parameters must match.
         if (targetIncludesParamSpec &&
-            ((_h = srcType.details.paramSpec) === null || _h === void 0 ? void 0 : _h.nameWithScope) === ((_j = destType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope)) {
+            ((_j = srcType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope) === ((_k = destType.details.paramSpec) === null || _k === void 0 ? void 0 : _k.nameWithScope)) {
             if (srcParamDetails.params.length !== destParamDetails.params.length) {
                 canAssign = false;
             }
@@ -18673,13 +18776,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const overrideParam = overrideParamDetails.params[i].param;
                 if (i >= baseParamDetails.positionOnlyParamCount &&
                     !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
-                    baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
+                    baseParamDetails.params[i].kind !== parameterUtils_1.ParameterKind.Positional &&
                     baseParam.category === 0 /* ParameterCategory.Simple */ &&
                     enforceParamNames &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* ParameterCategory.Simple */) {
                         if (!baseParam.isNameSynthesized) {
-                            if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
+                            if (overrideParamDetails.params[i].kind === parameterUtils_1.ParameterKind.Positional) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,
                                     baseName: baseParam.name || '*',
@@ -18698,8 +18801,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    if (!baseParam.isNameSynthesized &&
-                        baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly) {
+                    if (!baseParam.isNameSynthesized && baseParamDetails.params[i].kind !== parameterUtils_1.ParameterKind.Positional) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
                             baseName: baseParam.name || '*',
@@ -18737,7 +18839,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (enforceParamNames && overrideParamDetails.kwargsIndex === undefined) {
                 for (let i = positionalParamCount; i < baseParamDetails.positionParamCount; i++) {
                     const baseParam = baseParamDetails.params[i];
-                    if (baseParam.source === parameterUtils_1.ParameterSource.PositionOrKeyword &&
+                    if (baseParam.kind === parameterUtils_1.ParameterKind.Standard &&
                         baseParam.param.category === 0 /* ParameterCategory.Simple */) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
@@ -18770,10 +18872,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             // Now check any keyword-only parameters.
-            const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-                paramInfo.param.category === 0 /* ParameterCategory.Simple */);
-            const overrideKwOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-                paramInfo.param.category === 0 /* ParameterCategory.Simple */);
+            const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.kind === parameterUtils_1.ParameterKind.Keyword && paramInfo.param.category === 0 /* ParameterCategory.Simple */);
+            const overrideKwOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.kind === parameterUtils_1.ParameterKind.Keyword && paramInfo.param.category === 0 /* ParameterCategory.Simple */);
             baseKwOnlyParams.forEach((paramInfo) => {
                 var _a, _b, _c;
                 const overrideParamInfo = overrideKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);