@zzzen/pyright-internal 1.2.0-dev.20230319 → 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 */);
@@ -3517,6 +3536,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                     }
+                    // If the field was not found and the module type is marked
+                    // such that all fields should be Any/Unknown, return that type.
+                    if (!type && baseType.notPresentFieldType) {
+                        type = baseType.notPresentFieldType;
+                    }
                     if (!type) {
                         if (!isIncomplete) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleUnknownMember().format({
@@ -3659,7 +3683,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isIncomplete, isAsymmetricDescriptor, isRequired, isNotRequired };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
-        var _a, _b, _c;
+        var _a, _b;
         let classLookupFlags = 0 /* Default */;
         if (flags & 1 /* AccessClassMembersOnly */) {
             classLookupFlags |= 8 /* SkipInstanceVariables */;
@@ -3700,10 +3724,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (containingClassType &&
                         (0, types_1.isInstantiableClass)(containingClassType) &&
                         types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
-                        type = (_c = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+                        type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
                         if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
                             type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType);
                         }
+                        // If we're setting a class variable via a write through an object,
+                        // this is normally considered a type violation. But it is allowed
+                        // if the class variable is a descriptor object. In this case, we will
+                        // clear the flag that causes an error to be generated.
+                        if (usage.method === 'set' && memberInfo.symbol.isClassVar() && isAccessedThroughObject) {
+                            const selfClass = bindToType || memberName === '__new__' ? undefined : classType;
+                            const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
+                            if (typeResult) {
+                                if ((0, typeUtils_1.isDescriptorInstance)(typeResult.type, /* requireSetter */ true)) {
+                                    type = typeResult.type;
+                                    flags &= 8 /* DisallowClassVarWrites */;
+                                }
+                            }
+                        }
+                        if (!type) {
+                            type = types_1.UnknownType.create();
+                        }
                     }
                 }
             }
@@ -3748,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) &&
@@ -3803,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) {
@@ -3888,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) &&
@@ -3958,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)) {
@@ -4132,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.
@@ -4172,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)) {
@@ -4181,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();
                 }
             }
         }
@@ -4468,18 +4518,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeArgType = types_1.UnknownType.create();
                 }
                 if ((flags & 16384 /* EnforceTypeVarVarianceConsistency */) !== 0) {
-                    if ((0, types_1.isTypeVar)(typeArgType)) {
-                        const usageVariances = inferTypeParameterVarianceForTypeAlias(baseType);
-                        if (usageVariances && index < usageVariances.length) {
-                            const usageVariance = usageVariances[index];
-                            if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(typeArgType, usageVariance)) {
-                                const messageDiag = diag.createAddendum();
-                                messageDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForTypeAlias().format({
-                                    typeVarName: printType(typeArgType),
-                                    typeAliasParam: printType(typeParameters[index]),
-                                }));
-                                messageDiag.addTextRange(typeArgs[index].node);
-                            }
+                    const usageVariances = inferTypeParameterVarianceForTypeAlias(baseType);
+                    if (usageVariances && index < usageVariances.length) {
+                        const usageVariance = usageVariances[index];
+                        if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(typeArgType, usageVariance)) {
+                            const messageDiag = diag.createAddendum();
+                            messageDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.varianceMismatchForTypeAlias().format({
+                                typeVarName: printType(typeArgType),
+                                typeAliasParam: printType(typeParameters[index]),
+                            }));
+                            messageDiag.addTextRange(typeArgs[index].node);
                         }
                     }
                 }
@@ -4723,9 +4771,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // the type alias' type parameters?
                     subtype.typeArguments.forEach((typeArg, classParamIndex) => {
                         var _a;
-                        if (classParamIndex < subtype.details.typeParameters.length) {
+                        if ((0, typeUtils_1.isTupleClass)(subtype)) {
+                            updateUsageVarianceForType(typeArg, 3 /* Covariant */);
+                        }
+                        else if (classParamIndex < subtype.details.typeParameters.length) {
                             const classTypeParam = subtype.details.typeParameters[classParamIndex];
-                            updateUsageVarianceForType(typeArg, (_a = classTypeParam.computedVariance) !== null && _a !== void 0 ? _a : classTypeParam.details.declaredVariance);
+                            if ((0, types_1.isUnpackedClass)(typeArg) && typeArg.tupleTypeArguments) {
+                                typeArg.tupleTypeArguments.forEach((tupleTypeArg) => {
+                                    updateUsageVarianceForType(tupleTypeArg.type, 2 /* Invariant */);
+                                });
+                            }
+                            else {
+                                updateUsageVarianceForType(typeArg, (_a = classTypeParam.computedVariance) !== null && _a !== void 0 ? _a : classTypeParam.details.declaredVariance);
+                            }
                         }
                     });
                 }
@@ -4753,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);
@@ -4894,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) => {
@@ -4951,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,
         };
     }
@@ -6276,7 +6338,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
         /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g;
             switch (expandedSubtype.category) {
                 case 1 /* Unknown */:
                 case 2 /* Any */: {
@@ -6462,7 +6524,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 return types_1.AnyType.create();
                             }
                             if ((0, types_1.isClass)(unexpandedSubtype) && (0, enums_1.isKnownEnumType)(className)) {
-                                return (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList);
+                                return (_d = (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
                             }
                             if (className === 'TypedDict') {
                                 return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
@@ -6547,9 +6609,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return returnType;
                     }
                     else {
-                        const memberType = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
+                        const memberType = (_e = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
                         /* usage */ undefined, 
-                        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
+                        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _e === void 0 ? void 0 : _e.type;
                         if (memberType) {
                             const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
                             overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
@@ -6564,7 +6626,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 // will instantiate an object of type T.
                                 return (0, typeUtils_1.convertToInstance)(unexpandedSubtype);
                             }
-                            return (_e = functionResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
+                            return (_f = functionResult.returnType) !== null && _f !== void 0 ? _f : types_1.UnknownType.create();
                         }
                         if (!memberType || !(0, types_1.isAnyOrUnknown)(memberType)) {
                             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
@@ -6601,7 +6663,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (callResult.argumentErrors) {
                         argumentErrors = true;
                     }
-                    return (_f = callResult.returnType) !== null && _f !== void 0 ? _f : types_1.UnknownType.create();
+                    return (_g = callResult.returnType) !== null && _g !== void 0 ? _g : types_1.UnknownType.create();
                 }
                 case 8 /* Module */: {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleNotCallable(), errorNode);
@@ -6674,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;
@@ -6690,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,
                 });
             }
         });
@@ -7048,7 +7110,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Now consume any keyword arguments.
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* UnpackedDictionary */) {
-                    // Verify that the type used in this expression is a Mapping[str, T].
+                    // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
                     const argType = getTypeOfArgument(argList[argIndex]).type;
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
@@ -7132,7 +7194,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else {
-                        const mappingType = getTypingType(errorNode, 'Mapping');
+                        let mappingType = getTypeshedType(errorNode, 'SupportsKeysAndGetItem');
+                        if (!mappingType) {
+                            mappingType = getTypingType(errorNode, 'Mapping');
+                        }
                         const strObjType = getBuiltInObject(errorNode, 'str');
                         if (mappingType &&
                             (0, types_1.isInstantiableClass)(mappingType) &&
@@ -7708,7 +7773,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedReturnType.typeArguments &&
             specializedReturnType.typeArguments.length > 0) {
             if (boolClassType && (0, types_1.isInstantiableClass)(boolClassType)) {
-                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, specializedReturnType.typeArguments[0], types_1.ClassType.isBuiltIn(specializedReturnType, 'StrictTypeGuard')));
+                let typeGuardType = specializedReturnType.typeArguments[0];
+                // If the first argument is a simple (non-constrained) TypeVar,
+                // associate that TypeVar with the resulting TypeGuard type.
+                if (argResults.length > 0) {
+                    const arg0Type = argResults[0].argType;
+                    if ((0, types_1.isTypeVar)(arg0Type) &&
+                        !arg0Type.details.isParamSpec &&
+                        arg0Type.details.constraints.length === 0) {
+                        typeGuardType = (0, typeUtils_1.addConditionToType)(typeGuardType, [
+                            {
+                                typeVarName: types_1.TypeVarType.getNameWithScope(arg0Type),
+                                constraintIndex: 0,
+                                isConstrainedTypeVar: false,
+                            },
+                        ]);
+                    }
+                }
+                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, types_1.ClassType.isBuiltIn(specializedReturnType, 'StrictTypeGuard')));
             }
         }
         specializedReturnType = adjustCallableReturnType(specializedReturnType);
@@ -11565,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
@@ -12065,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();
@@ -14989,8 +15073,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
                 }
-                else if (!loaderActions.implicitImports) {
-                    return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
+                else {
+                    // Note that all module attributes that are not found in the
+                    // symbol table should be treated as Any or Unknown rather than
+                    // as an error.
+                    moduleType.notPresentFieldType = evaluatorOptions.evaluateUnknownImportsAsAny
+                        ? types_1.AnyType.create()
+                        : types_1.UnknownType.create();
                 }
             }
             if (loaderActions.implicitImports) {
@@ -15205,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
@@ -15312,6 +15401,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (sawExplicitTypeAlias) {
                 considerDecl = false;
             }
+            // If the symbol is explicitly marked as a ClassVar, consider only the
+            // declarations that assign to it from within the class body, not through
+            // a member access expression.
+            if (symbol.isClassVar() && decl.type === 1 /* Variable */ && decl.isDefinedByMemberAccess) {
+                considerDecl = false;
+            }
             if (usageNode !== undefined) {
                 if (decl.type !== 8 /* Alias */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
@@ -15549,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) {
@@ -16025,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,
@@ -16296,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);
                 }
@@ -17128,6 +17218,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!constructorFunction.details.docString && classType.details.docString) {
                         constructorFunction.details.docString = classType.details.docString;
                     }
+                    constructorFunction.details.flags &= ~4 /* StaticMethod */;
                 }
                 return constructorFunction;
             };
@@ -17165,6 +17256,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!constructorFunction.details.docString && classType.details.docString) {
                         constructorFunction.details.docString = classType.details.docString;
                     }
+                    constructorFunction.details.flags &= ~(4 /* StaticMethod */ | 1 /* ConstructorMethod */);
                 }
                 return constructorFunction;
             };
@@ -17189,7 +17281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Return a generic constructor.
-        const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+        const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 0 /* None */);
         constructorFunction.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
         types_1.FunctionType.addDefaultParameters(constructorFunction);
         if (!constructorFunction.details.docString && classType.details.docString) {
@@ -17321,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;
         }
@@ -17370,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),
             ];
@@ -17378,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));
         }
@@ -17392,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
@@ -17412,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 */ &&
@@ -17507,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 : '',
@@ -17902,12 +17994,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return narrowedSubtype;
         });
         // If the result of narrowing is Any, stick with the declared (unnarrowed) type.
-        // If the result of narrowing is an Unknown that is complete, stick with Unknown.
-        // If it's incomplete, propagate the incomplete type for the benefit of
-        // code flow analysis.
-        if ((0, types_1.isAnyOrUnknown)(assignedType) && !(0, typeUtils_1.isIncompleteUnknown)(assignedType)) {
+        // If the result of narrowing is an Unknown that is incomplete, propagate the
+        // incomplete type for the benefit of code flow analysis.
+        // If the result of narrowing is a complete Unknown, combine the Unknown type
+        // with the declared type. In strict mode, this will retain the "unknown type"
+        // diagnostics while still providing reasonable completion suggestions.
+        if ((0, types_1.isAny)(narrowedType)) {
             return declaredType;
         }
+        else if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
+            return narrowedType;
+        }
+        else if ((0, types_1.isUnknown)(narrowedType)) {
+            return (0, types_1.combineTypes)([narrowedType, declaredType]);
+        }
         return narrowedType;
     }
     function validateOverrideMethod(baseMethod, overrideMethod, diag, enforceParamNames = true) {
@@ -17946,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.
@@ -18026,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 || '*',
@@ -18103,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;