@zzzen/pyright-internal 1.2.0-dev.20230326 → 1.2.0-dev.20230409

package/dist/analyzer/typeEvaluator.js

@@ -46,7 +46,6 @@ const textRange_1 = require("../common/textRange");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const parser_1 = require("../parser/parser");
-const DeclarationUtils = __importStar(require("./aliasDeclarationUtils"));
 const analyzerFileInfo_1 = require("./analyzerFileInfo");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowEngine_1 = require("./codeFlowEngine");
@@ -58,6 +57,7 @@ const declarationUtils_1 = require("./declarationUtils");
 const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
+const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const patternMatching_1 = require("./patternMatching");
 const properties_1 = require("./properties");
@@ -254,6 +254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let dictClassType;
     let typedDictClassType;
     let typedDictPrivateClassType;
+    let mappingType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
@@ -503,6 +504,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             dictClassType = getBuiltInType(node, 'dict');
             typedDictClassType = getTypingType(node, 'TypedDict');
             typedDictPrivateClassType = getTypingType(node, '_TypedDict');
+            mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!mappingType) {
+                // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
+                mappingType = getTypingType(node, 'Mapping');
+            }
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
@@ -930,7 +936,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
                     // Handle "LiteralString" specially.
                     if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                        return types_1.ClassType.cloneAsInstance(strClassType);
+                        let strInstance = types_1.ClassType.cloneAsInstance(strClassType);
+                        if (subtype.condition) {
+                            strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
+                        }
+                        return strInstance;
                     }
                 }
             }
@@ -2153,7 +2163,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const setTypeResult = getTypeOfMemberAccessWithBaseType(target, baseTypeResult, { method: 'set', setType: type, setErrorNode: srcExpr, setExpectedTypeDiag: expectedTypeDiagAddendum }, 0 /* None */);
+        const setTypeResult = getTypeOfMemberAccessWithBaseType(target, baseTypeResult, {
+            method: 'set',
+            setType: { type, isIncomplete: isTypeIncomplete },
+            setErrorNode: srcExpr,
+            setExpectedTypeDiag: expectedTypeDiagAddendum,
+        }, 0 /* None */);
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
@@ -2263,11 +2278,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const sourceEntryTypes = tupleType.tupleTypeArguments.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype)));
                 const unboundedIndex = tupleType.tupleTypeArguments.findIndex((t) => t.isUnbounded);
                 if (unboundedIndex >= 0) {
-                    if (sourceEntryTypes.length > targetTypes.length) {
-                        // Splice out the unbounded since it might be zero length.
-                        sourceEntryTypes.splice(unboundedIndex, 1);
-                    }
-                    else if (sourceEntryTypes.length < targetTypes.length) {
+                    if (sourceEntryTypes.length < targetTypes.length) {
                         const typeToReplicate = sourceEntryTypes.length > 0 ? sourceEntryTypes[unboundedIndex] : types_1.AnyType.create();
                         // Add elements to make the count match the target count.
                         while (sourceEntryTypes.length < targetTypes.length) {
@@ -2340,7 +2351,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // used as type arguments in other types) with their concrete form.
     // If conditionFilter is specified and the TypeVar is a constrained
     // TypeVar, only the conditions that match the filter will be included.
-    function makeTopLevelTypeVarsConcrete(type, conditionFilter) {
+    function makeTopLevelTypeVarsConcrete(type, makeParamSpecsConcrete = false, conditionFilter) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.paramSpecAccess === 'args') {
@@ -2365,6 +2376,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return types_1.UnknownType.create();
                 }
             }
+            // If this is a function that contains only a ParamSpec (no additional
+            // parameters), convert it to a concrete type of (*args: Any, **kwargs: Any).
+            if (makeParamSpecsConcrete &&
+                (0, types_1.isFunction)(subtype) &&
+                subtype.details.parameters.length === 0 &&
+                subtype.details.paramSpec) {
+                const concreteFunction = types_1.FunctionType.createInstance('', '', '', 64 /* SynthesizedMethod */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+                types_1.FunctionType.addDefaultParameters(concreteFunction);
+                return types_1.FunctionType.cloneForParamSpec(subtype, concreteFunction);
+            }
             // If this is a TypeVarTuple *Ts, convert it to an unpacked tuple
             // *tuple[*Ts].
             if ((0, types_1.isVariadicTypeVar)(subtype)) {
@@ -2557,7 +2578,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* DoNotSpecialize */);
                 getTypeOfIndexWithBaseType(target, baseTypeResult, {
                     method: 'set',
-                    setType: type,
+                    setType: { type, isIncomplete: isTypeIncomplete },
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
                 }, 0 /* None */);
@@ -3770,12 +3791,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type = descriptorResult.type;
             if (usage.method === 'set' && usage.setType) {
                 // Verify that the assigned type is compatible.
-                if (!assignType(type, usage.setType, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberAssignment().format({
-                        type: printType(usage.setType),
-                        name: memberName,
-                        classType: printObjectTypeForClass(classType),
-                    }));
+                if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
+                    if (!usage.setType.isIncomplete) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberAssignment().format({
+                            type: printType(usage.setType.type),
+                            name: memberName,
+                            classType: printObjectTypeForClass(classType),
+                        }));
+                    }
                     return undefined;
                 }
                 if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
@@ -3825,7 +3848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeValid = true;
         let isAsymmetricDescriptor = false;
         type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a;
+            var _a, _b, _c;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
             const isClassMember = !memberInfo || memberInfo.isClassMember;
             if ((0, types_1.isClass)(concreteSubtype) && isClassMember) {
@@ -3910,7 +3933,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // Provide "value" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                typeResult: { type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create() },
+                                typeResult: {
+                                    type: (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
+                                    isIncomplete: !!((_c = usage.setType) === null || _c === void 0 ? void 0 : _c.isIncomplete),
+                                },
                             });
                         }
                         if (types_1.ClassType.isPropertyClass(lookupClass) &&
@@ -3980,11 +4006,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         if (usage.method === 'set') {
                                             if (usage.setType &&
                                                 (0, types_1.isFunction)(boundMethodType) &&
-                                                boundMethodType.details.parameters.length >= 2) {
+                                                boundMethodType.details.parameters.length >= 2 &&
+                                                !usage.setType.isIncomplete) {
                                                 const setterType = types_1.FunctionType.getEffectiveParameterType(boundMethodType, 1);
                                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeIncompatible().format({
                                                     destType: printType(setterType),
-                                                    sourceType: printType(usage.setType),
+                                                    sourceType: printType(usage.setType.type),
                                                 }));
                                             }
                                             else if ((0, types_1.isOverloadedFunction)(boundMethodType)) {
@@ -4154,7 +4181,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
     function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const getAttributeAccessMember = (name) => {
             var _a;
             // See if the class has a "__getattribute__" or "__getattr__" method.
@@ -4194,7 +4221,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argList.push({
                     // Provide "value" argument.
                     argumentCategory: 0 /* Simple */,
-                    typeResult: { type: (_b = usage.setType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create() },
+                    typeResult: {
+                        type: (_c = (_b = usage.setType) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
+                        isIncomplete: !!((_d = usage.setType) === null || _d === void 0 ? void 0 : _d.isIncomplete),
+                    },
                 });
             }
             if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
@@ -4203,7 +4233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
                     const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
                     /* skipUnknownArgCheck */ true);
-                    return (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+                    return (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
                 }
             }
         }
@@ -4783,7 +4813,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfIndexedObjectOrClass(node, baseType, usage) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         // Handle index operations for TypedDict classes specially.
         if ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isTypedDictClass(baseType)) {
             const typeFromTypedDict = (0, typedDicts_1.getTypeOfIndexedTypedDict)(evaluatorInterface, node, baseType, usage);
@@ -4924,15 +4954,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             },
         ];
         if (usage.method === 'set') {
-            let setType = usage.setType || types_1.AnyType.create();
+            let setType = (_d = (_c = usage.setType) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : types_1.AnyType.create();
             // Expand constrained type variables.
             if ((0, types_1.isTypeVar)(setType) && setType.details.constraints.length > 0) {
                 const conditionFilter = (0, types_1.isClassInstance)(baseType) ? baseType.condition : undefined;
-                setType = makeTopLevelTypeVarsConcrete(setType, conditionFilter);
+                setType = makeTopLevelTypeVarsConcrete(setType, 
+                /* makeParamSpecsConcrete */ undefined, conditionFilter);
             }
             argList.push({
                 argumentCategory: 0 /* Simple */,
-                typeResult: { type: setType, isIncomplete: isPositionalIndexTypeIncomplete },
+                typeResult: {
+                    type: setType,
+                    isIncomplete: !!((_e = usage.setType) === null || _e === void 0 ? void 0 : _e.isIncomplete),
+                },
             });
         }
         keywordArgs.forEach((arg) => {
@@ -4981,7 +5015,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            type: (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
+            type: (_f = callResult.returnType) !== null && _f !== void 0 ? _f : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
@@ -5999,7 +6033,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // one or more analyzes with no errors, use those results.
             if (inferenceContext) {
                 const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
-                if (expectedCallResult) {
+                if (expectedCallResult && !expectedCallResult.argumentErrors) {
                     returnType = expectedCallResult.returnType;
                     if (expectedCallResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
@@ -6061,12 +6095,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (constructorMethodInfo && !skipConstructorCheck(constructorMethodInfo.type)) {
                 const constructorMethodType = constructorMethodInfo.type;
+                let newReturnType;
                 // If there is an expected type that was not applied above when
                 // handling the __init__ method, try to apply it with the __new__ method.
                 if (inferenceContext && !returnType) {
                     const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
-                    if (expectedCallResult) {
-                        returnType = expectedCallResult.returnType;
+                    if (expectedCallResult && !expectedCallResult.argumentErrors) {
+                        newReturnType = expectedCallResult.returnType;
+                        returnType = newReturnType;
                         if (expectedCallResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
@@ -6096,8 +6132,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (callResult.argumentErrors) {
                     reportedErrors = true;
                 }
-                else {
-                    let newReturnType = callResult.returnType;
+                else if (!newReturnType) {
+                    newReturnType = callResult.returnType;
                     // If the constructor returned an object whose type matches the class of
                     // the original type being constructed, use the return type in case it was
                     // specialized. If it doesn't match, we'll fall back on the assumption that
@@ -6704,7 +6740,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const paramDetails = (0, typeUtils_1.getParameterListDetails)(typeResult.type);
+        const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
         let reportedArgError = false;
@@ -6720,7 +6756,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 paramMap.set(param.name, {
                     argsNeeded: param.category === 0 /* Simple */ && !param.hasDefault ? 1 : 0,
                     argsReceived: 0,
-                    isPositionalOnly: paramInfo.source === typeUtils_1.ParameterSource.PositionOnly,
+                    isPositionalOnly: paramInfo.source === parameterUtils_1.ParameterSource.PositionOnly,
                 });
             }
         });
@@ -7162,10 +7198,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else {
-                        let mappingType = getTypeshedType(errorNode, 'SupportsKeysAndGetItem');
-                        if (!mappingType) {
-                            mappingType = getTypingType(errorNode, 'Mapping');
-                        }
                         const strObjType = getBuiltInObject(errorNode, 'str');
                         if (mappingType &&
                             (0, types_1.isInstantiableClass)(mappingType) &&
@@ -7600,28 +7632,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // where more than two passes are needed.
             let passCount = Math.min(typeVarMatchingCount, 2);
             for (let i = 0; i < passCount; i++) {
+                const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
-                        if (argParam.requiresTypeVarMatching) {
-                            // Populate the typeVarContext for the argument. If the argument
-                            // is an overload function, skip it during the first pass
-                            // because the selection of the proper overload may depend
-                            // on type arguments supplied by other function arguments.
-                            // Set useNarrowBoundOnly to true the first time through
-                            // the loop if we're going to go through the loop multiple
-                            // times.
-                            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-                            /* skipOverloadArg */ i === 0, 
-                            /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
-                            if (argResult.isTypeIncomplete) {
-                                isTypeIncomplete = true;
-                            }
-                            // If we skipped a overload arg during the first pass,
-                            // add another pass to ensure that we handle all of the
-                            // type variables.
-                            if (i === 0 && argResult.skippedOverloadArg) {
-                                passCount++;
-                            }
+                        if (!argParam.requiresTypeVarMatching) {
+                            return;
+                        }
+                        // Populate the typeVarContext for the argument. If the argument
+                        // is an overload function, skip it during the first pass
+                        // because the selection of the proper overload may depend
+                        // on type arguments supplied by other function arguments.
+                        // Set useNarrowBoundOnly to true the first time through
+                        // the loop if we're going to go through the loop multiple
+                        // times.
+                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
+                        /* skipOverloadArg */ i === 0, 
+                        /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
+                        if (argResult.isTypeIncomplete) {
+                            isTypeIncomplete = true;
+                        }
+                        // If we skipped a overload arg during the first pass,
+                        // add another pass to ensure that we handle all of the
+                        // type variables.
+                        if (i === 0 && argResult.skippedOverloadArg) {
+                            passCount++;
                         }
                     });
                 });
@@ -7634,9 +7668,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecKwargs = false;
         let condition = [];
         const argResults = [];
+        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         matchResults.argParams.forEach((argParam) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
+            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
             /* skipOverloadArg */ false, 
             /* useNarrowBoundOnly */ false, typeCondition);
             argResults.push(argResult);
@@ -7859,6 +7894,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
         const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
+        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         argList.forEach((arg) => {
             var _a;
             if (arg.argumentCategory === 0 /* Simple */) {
@@ -7905,7 +7941,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
-                    }, srcTypeVarContext, 
+                    }, srcTypeVarContext, signatureTracker, 
                     /* functionType */ undefined, 
                     /* skipUnknownArgCheck */ false, 
                     /* skipOverloadArg */ false, 
@@ -7941,7 +7977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -8014,6 +8050,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        // If the type includes multiple instances of a generic function
+        // signature, force the type arguments for the duplicates to have
+        // unique names.
+        argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
@@ -9483,13 +9523,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addUnknown = false;
             }
             else if (entryNode.nodeType === 16 /* DictionaryExpandEntry */) {
-                // Verify that the type supports the `keys` and `__getitem__` methods.
-                // This protocol is defined in the _typeshed stub. If we can't find
-                // it there, fall back on typing.Mapping.
-                let mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-                if (!mappingType) {
-                    mappingType = getTypingType(node, 'Mapping');
-                }
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
                     if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
@@ -9521,30 +9554,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addUnknown = false;
                     }
                 }
-                else {
-                    if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                        const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
-                        // Self-specialize the class.
-                        mappingType = types_1.ClassType.cloneForSpecialization(mappingType, mappingType.details.typeParameters, 
-                        /* isTypeArgumentExplicit */ true);
-                        if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
-                        /* diag */ undefined, mappingTypeVarContext, 
-                        /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
-                            const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
-                            const typeArgs = specializedMapping.typeArguments;
-                            if (typeArgs && typeArgs.length >= 2) {
-                                if (forceStrictInference || index < maxEntriesToUseForInference) {
-                                    keyTypes.push({ node: entryNode, type: typeArgs[0] });
-                                    valueTypes.push({ node: entryNode, type: typeArgs[1] });
-                                }
-                                addUnknown = false;
+                else if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
+                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
+                    // Self-specialize the class.
+                    mappingType = types_1.ClassType.cloneForSpecialization(mappingType, mappingType.details.typeParameters, 
+                    /* isTypeArgumentExplicit */ true);
+                    if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
+                    /* diag */ undefined, mappingTypeVarContext, 
+                    /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
+                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                        const typeArgs = specializedMapping.typeArguments;
+                        if (typeArgs && typeArgs.length >= 2) {
+                            if (forceStrictInference || index < maxEntriesToUseForInference) {
+                                keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                                valueTypes.push({ node: entryNode, type: typeArgs[1] });
                             }
-                        }
-                        else {
-                            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictUnpackIsNotMapping(), entryNode);
+                            addUnknown = false;
                         }
                     }
+                    else {
+                        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictUnpackIsNotMapping(), entryNode);
+                    }
                 }
             }
             else if (entryNode.nodeType === 32 /* ListComprehension */) {
@@ -11615,7 +11646,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // The scope for this class becomes the "fields" for the corresponding type.
         const innerScope = ScopeUtils.getScopeForNode(node.suite);
-        classType.details.fields = (innerScope === null || innerScope === void 0 ? void 0 : innerScope.symbolTable) || new Map();
+        classType.details.fields = (innerScope === null || innerScope === void 0 ? void 0 : innerScope.symbolTable)
+            ? new Map(innerScope.symbolTable)
+            : new Map();
         // Determine whether the class's instance variables are constrained
         // to those defined by __slots__. We need to do this prior to dataclass
         // processing because dataclasses can implicitly add to the slots
@@ -12115,7 +12148,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (newMethodMember) {
                 const newMethodType = getTypeOfMember(newMethodMember);
                 if ((0, types_1.isFunction)(newMethodType)) {
-                    const paramListDetails = (0, typeUtils_1.getParameterListDetails)(newMethodType);
+                    const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(newMethodType);
                     if (paramListDetails.firstKeywordOnlyIndex !== undefined) {
                         // Build a map of the keyword-only parameters.
                         const paramMap = new Map();
@@ -12127,6 +12160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         argList.forEach((arg) => {
                             var _a, _b, _c;
+                            const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
                             if (arg.argumentCategory === 0 /* Simple */ && arg.name) {
                                 const paramIndex = (_a = paramMap.get(arg.name.value)) !== null && _a !== void 0 ? _a : paramListDetails.kwargsIndex;
                                 if (paramIndex !== undefined) {
@@ -12138,7 +12172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argument: arg,
                                         errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), { type: newMethodType }, 
+                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, 
                                     /* skipUnknownCheck */ true, 
                                     /* skipOverloadArg */ true, 
                                     /* useNarrowBoundOnly */ false, 
@@ -13269,9 +13303,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return getExceptionType(subType, node.typeExpression);
         });
-        // If this is an except group, wrap the exception type in an ExceptionGroup.
+        // If this is an except group, wrap the exception type in an BaseExceptionGroup.
         if (node.isExceptGroup) {
-            targetType = getBuiltInObject(node, 'ExceptionGroup', [targetType]);
+            targetType = getBuiltInObject(node, 'BaseExceptionGroup', [targetType]);
         }
         if (node.name) {
             assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
@@ -15260,10 +15294,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // resolves aliases through local renames ("as" clauses found in import statements).
     function resolveAliasDeclaration(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
         var _a;
-        return (_a = DeclarationUtils.resolveAliasDeclaration(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess)) === null || _a === void 0 ? void 0 : _a.declaration;
+        return (_a = (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess)) === null || _a === void 0 ? void 0 : _a.declaration;
     }
     function resolveAliasDeclarationWithInfo(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
-        return DeclarationUtils.resolveAliasDeclaration(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess);
+        return (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess);
     }
     // Returns the type of the symbol. If the type is explicitly declared, that type
     // is returned. If not, the type is inferred from assignments to the symbol. All
@@ -15463,33 +15497,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         });
+        // How many times have we already attempted to evaluate this declaration already?
+        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
+        let resultType;
         if (typesToCombine.length > 0) {
-            // How many times have we already attempted to evaluate this declaration already?
-            const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
             // Ignore the pending evaluation flag if we've already attempted the
             // type evaluation many times because this probably means there's a
             // cyclical dependency that cannot be broken.
             isIncomplete = sawPendingEvaluation && evaluationAttempts < maxEffectiveTypeEvaluationAttempts;
-            const result = {
-                type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete,
-                includesVariableDecl,
-                includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
-                isRecursiveDefinition: false,
-                evaluationAttempts,
-            };
-            if (!includesSpeculativeResult) {
-                addToEffectiveTypeCache(result);
-            }
-            return result;
+            resultType = (0, types_1.combineTypes)(typesToCombine);
         }
-        return {
-            type: types_1.UnboundType.create(),
+        else {
+            resultType = types_1.UnboundType.create();
+        }
+        const result = {
+            type: resultType,
             isIncomplete,
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
             isRecursiveDefinition: false,
+            evaluationAttempts,
         };
+        if (!includesSpeculativeResult) {
+            addToEffectiveTypeCache(result);
+        }
+        return result;
         function addToEffectiveTypeCache(result) {
             // Add the entry to the cache so we don't need to compute it next time.
             if (!cacheEntries) {
@@ -15610,6 +15642,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (types_1.FunctionType.isStubDefinition(type)) {
             return types_1.UnknownType.create();
         }
+        // Don't infer the return type for an overloaded function (unless it's synthesized,
+        // which is needed for proper operation of the __get__ method in properties).
+        if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
+            return types_1.UnknownType.create();
+        }
         // If the return type has already been lazily evaluated,
         // don't bother computing it again.
         if (type.inferredReturnType) {
@@ -16020,7 +16057,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isAssignable;
     }
-    function assignTupleTypeArgs(destType, srcType, diag, typeVarContext, flags, recursionCount) {
+    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
@@ -16074,8 +16111,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (srcTypeArgs.length === destTypeArgs.length) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-                if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     if (entryDiag) {
                         entryDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleEntryTypeMismatch().format({
                             entry: argIndex + 1,
@@ -16086,17 +16122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            if (srcUnboundedIndex >= 0) {
-                // PEP 646 allows an indeterminate tuple type to be assigned to
-                // a determinate tuple type if it's associated with a TypeVarTuple.
-                if (!destType.isUnpacked) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeMismatchIndeterminate().format({
-                        expected: destTypeArgs.length,
-                    }));
-                    return false;
-                }
-            }
-            else {
+            if (srcUnboundedIndex < 0) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeMismatch().format({
                     expected: destTypeArgs.length,
                     received: srcTypeArgs.length,
@@ -16144,7 +16170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle built-in types that support arbitrary numbers
             // of type parameters like Tuple.
             if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-                return assignTupleTypeArgs(destType, curSrcType, diag, curDestTypeVarContext, flags, recursionCount);
+                return assignTupleTypeArgs(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
             }
             // If there are no type parameters on this class, we're done.
             const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
@@ -16219,6 +16245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destTypeArgs = destType.typeArguments;
             srcTypeArgs = srcType.typeArguments;
         }
+        let isCompatible = true;
         if (srcTypeArgs) {
             for (let srcArgIndex = 0; srcArgIndex < srcTypeArgs.length; srcArgIndex++) {
                 const srcTypeArg = srcTypeArgs[srcArgIndex];
@@ -16243,7 +16270,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 diag.addAddendum(assignmentDiag);
                             }
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
@@ -16255,7 +16282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }));
                             childDiag.addAddendum(assignmentDiag);
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else {
@@ -16270,13 +16297,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }));
                                 childDiag.addAddendum(assignmentDiag);
                             }
-                            return false;
+                            isCompatible = false;
                         }
                     }
                 }
             }
         }
-        return true;
+        return isCompatible;
     }
     // Determines if the source type can be assigned to the dest type.
     // If typeVarContext is provided, type variables within the destType are
@@ -16357,7 +16384,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Before performing any other checks, see if the dest type is a
         // TypeVar that we are attempting to match.
         if ((0, types_1.isTypeVar)(destType)) {
-            if ((0, types_1.isTypeSame)(destType, srcType)) {
+            if ((0, typeUtils_1.isTypeVarSame)(destType, srcType)) {
                 if (destType.scopeId && (destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.hasSolveForScope(destType.scopeId))) {
                     return (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
                 }
@@ -16484,6 +16511,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((0, types_1.isNever)(srcType)) {
+            if ((flags & 1 /* EnforceInvariance */) !== 0) {
+                return (0, types_1.isNever)(destType);
+            }
             const targetTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
                 (0, typeUtils_1.setTypeArgumentsRecursive)(destType, types_1.UnknownType.create(), targetTypeVarContext, recursionCount);
@@ -16665,9 +16695,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (destCallbackType) {
                     return assignType(destCallbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
-                // All functions are objects, so try to assign as an object.
-                if (objectType && (0, types_1.isClassInstance)(objectType)) {
-                    return assignType(destType, objectType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                // All functions are considered instances of "builtins.function".
+                if (functionObj && (0, types_1.isClassInstance)(functionObj)) {
+                    return assignType(destType, functionObj, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17384,7 +17414,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (srcDetails.params.length < destDetails.argsIndex) {
             return;
         }
-        let srcLastToPackIndex = srcDetails.params.findIndex((p, i) => i >= destDetails.argsIndex && p.source === typeUtils_1.ParameterSource.KeywordOnly);
+        let srcLastToPackIndex = srcDetails.params.findIndex((p, i) => i >= destDetails.argsIndex && p.source === parameterUtils_1.ParameterSource.KeywordOnly);
         if (srcLastToPackIndex < 0) {
             srcLastToPackIndex = srcDetails.params.length;
         }
@@ -17433,7 +17463,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     },
                     type: srcPositionalsType,
                     index: -1,
-                    source: typeUtils_1.ParameterSource.PositionOnly,
+                    source: parameterUtils_1.ParameterSource.PositionOnly,
                 },
                 ...srcDetails.params.slice(destDetails.argsIndex + srcPositionalsToPack.length, srcDetails.params.length),
             ];
@@ -17441,9 +17471,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             srcDetails.argsIndex = argsIndex >= 0 ? argsIndex : undefined;
             const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* VarArgDictionary */);
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
-            const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === typeUtils_1.ParameterSource.KeywordOnly);
+            const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === parameterUtils_1.ParameterSource.KeywordOnly);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
-            srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.source !== typeUtils_1.ParameterSource.PositionOnly ||
+            srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.source !== parameterUtils_1.ParameterSource.PositionOnly ||
                 p.param.category !== 0 /* Simple */ ||
                 p.param.hasDefault));
         }
@@ -17455,8 +17485,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         flags &= ~32 /* SkipFunctionReturnTypeCheck */;
         destType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(destType);
         srcType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(srcType);
-        const destParamDetails = (0, typeUtils_1.getParameterListDetails)(destType);
-        const srcParamDetails = (0, typeUtils_1.getParameterListDetails)(srcType);
+        const destParamDetails = (0, parameterUtils_1.getParameterListDetails)(destType);
+        const srcParamDetails = (0, parameterUtils_1.getParameterListDetails)(srcType);
         adjustSourceParamDetailsForDestVariadic(srcParamDetails, destParamDetails);
         const targetIncludesParamSpec = (flags & 2 /* ReverseTypeVarMatching */) !== 0
             ? !!srcType.details.paramSpec
@@ -17475,7 +17505,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const destParamName = (_e = destParam.param.name) !== null && _e !== void 0 ? _e : '';
             const srcParamName = (_f = srcParam.param.name) !== null && _f !== void 0 ? _f : '';
             if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
-                const isDestPositionalOnly = destParam.source === typeUtils_1.ParameterSource.PositionOnly;
+                const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* VarArgList */ &&
                     srcParam.param.category !== 1 /* VarArgList */ &&
@@ -17570,7 +17600,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         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 !== typeUtils_1.ParameterSource.PositionOnly &&
+                        if (destParamDetails.params[paramIndex].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInSource().format({
                                 name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : '',
@@ -18017,8 +18047,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
         var _a, _b;
-        const baseParamDetails = (0, typeUtils_1.getParameterListDetails)(baseMethod);
-        const overrideParamDetails = (0, typeUtils_1.getParameterListDetails)(overrideMethod);
+        const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
+        const overrideParamDetails = (0, parameterUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
         // Verify that we're not overriding a static, class or instance method with
         // an incompatible type.
@@ -18097,12 +18127,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const overrideParam = overrideParamDetails.params[i].param;
             if (i >= baseParamDetails.positionOnlyParamCount &&
                 !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
-                baseParamDetails.params[i].source !== typeUtils_1.ParameterSource.PositionOnly &&
+                baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                 baseParam.category === 0 /* Simple */ &&
                 baseParam.name !== overrideParam.name) {
                 if (overrideParam.category === 0 /* Simple */) {
                     if (enforceParamNames) {
-                        if (overrideParamDetails.params[i].source === typeUtils_1.ParameterSource.PositionOnly) {
+                        if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                 index: i + 1,
                                 baseName: baseParam.name || '*',
@@ -18174,9 +18204,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Now check any keyword-only parameters.
-        const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === typeUtils_1.ParameterSource.KeywordOnly &&
+        const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
             paramInfo.param.category === 0 /* Simple */);
-        const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === typeUtils_1.ParameterSource.KeywordOnly &&
+        const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
             paramInfo.param.category === 0 /* Simple */);
         baseKwOnlyParams.forEach((paramInfo) => {
             var _a, _b, _c;