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

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");
@@ -930,7 +930,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 +2157,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);
         }
@@ -2340,7 +2349,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 +2374,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 +2576,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 +3789,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 +3846,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 +3931,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 +4004,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 +4179,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 +4219,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 +4231,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 +4811,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 +4952,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 +5013,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,
         };
     }
@@ -6704,7 +6736,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 +6752,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,
                 });
             }
         });
@@ -11615,7 +11647,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 +12149,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();
@@ -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
@@ -15610,6 +15644,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) {
@@ -16086,17 +16125,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,
@@ -16357,7 +16386,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);
                 }
@@ -17384,7 +17413,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 +17462,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 +17470,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 +17484,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 +17504,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 +17599,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 +18046,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 +18126,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 +18203,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;