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

package/dist/analyzer/sourceFileInfoUtils.d.ts

@@ -1,2 +1,3 @@
 import { SourceFileInfo } from './program';
 export declare function isUserCode(fileInfo: SourceFileInfo | undefined): boolean;
+export declare function collectImportedByFiles(fileInfo: SourceFileInfo): Set<SourceFileInfo>;

package/dist/analyzer/sourceFileInfoUtils.js

@@ -7,9 +7,25 @@
  * Collection of functions that operate on SourceFileInfo objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUserCode = void 0;
+exports.collectImportedByFiles = exports.isUserCode = void 0;
 function isUserCode(fileInfo) {
     return !!fileInfo && fileInfo.isTracked && !fileInfo.isThirdPartyImport && !fileInfo.isTypeshedFile;
 }
 exports.isUserCode = isUserCode;
+function collectImportedByFiles(fileInfo) {
+    const importedByFiles = new Set();
+    _collectImportedByFiles(fileInfo, importedByFiles);
+    return importedByFiles;
+}
+exports.collectImportedByFiles = collectImportedByFiles;
+function _collectImportedByFiles(fileInfo, importedByFiles) {
+    fileInfo.importedBy.forEach((dep) => {
+        if (importedByFiles.has(dep)) {
+            // Already visited.
+            return;
+        }
+        importedByFiles.add(dep);
+        _collectImportedByFiles(dep, importedByFiles);
+    });
+}
 //# sourceMappingURL=sourceFileInfoUtils.js.map

package/dist/analyzer/sourceFileInfoUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"sourceFileInfoUtils.js","sourceRoot":"","sources":["../../../src/analyzer/sourceFileInfoUtils.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAIH,SAAgB,UAAU,CAAC,QAAoC;IAC3D,OAAO,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,kBAAkB,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;AACxG,CAAC;AAFD,gCAEC"}
+{"version":3,"file":"sourceFileInfoUtils.js","sourceRoot":"","sources":["../../../src/analyzer/sourceFileInfoUtils.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAIH,SAAgB,UAAU,CAAC,QAAoC;IAC3D,OAAO,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,kBAAkB,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;AACxG,CAAC;AAFD,gCAEC;AAED,SAAgB,sBAAsB,CAAC,QAAwB;IAC3D,MAAM,eAAe,GAAG,IAAI,GAAG,EAAkB,CAAC;IAClD,uBAAuB,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IACnD,OAAO,eAAe,CAAC;AAC3B,CAAC;AAJD,wDAIC;AAED,SAAS,uBAAuB,CAAC,QAAwB,EAAE,eAAoC;IAC3F,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;QAChC,IAAI,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YAC1B,mBAAmB;YACnB,OAAO;SACV;QAED,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACzB,uBAAuB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/analyzer/typeEvaluator.js

@@ -705,11 +705,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if (flags & 65536 /* DisallowRecursiveTypeAliasPlaceholder */) {
-            if ((0, types_1.isTypeVar)(typeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
-                typeResult.type.details.illegalRecursionDetected = true;
-            }
-        }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
@@ -946,7 +941,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
             allowTypeVarTuple: paramCategory === 1 /* VarArgList */,
-            disallowRecursiveTypeAlias: true,
             allowUnpackedTypedDict: paramCategory === 2 /* VarArgDictionary */,
             allowUnpackedTuple: paramCategory === 1 /* VarArgList */,
         });
@@ -990,9 +984,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             evaluatorFlags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
         }
-        if (options === null || options === void 0 ? void 0 : options.disallowRecursiveTypeAlias) {
-            evaluatorFlags |= 65536 /* DisallowRecursiveTypeAliasPlaceholder */;
-        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
             evaluatorFlags |= 8388608 /* AllowUnpackedTypedDict */;
         }
@@ -3526,6 +3517,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({
@@ -3668,7 +3664,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 */;
@@ -3709,10 +3705,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();
+                        }
                     }
                 }
             }
@@ -4477,18 +4490,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);
                         }
                     }
                 }
@@ -4548,10 +4559,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if the class has a custom metaclass that supports __getitem__, etc.
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
-                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta'])) {
+                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
+                    (flags & 128 /* ExpectingType */) === 0) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
+                    if (flags & 256 /* ExpectingTypeAnnotation */) {
+                        // If the class doesn't derive from Generic, a type argument should not be allowed.
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
+                            name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
+                        }), node);
+                    }
                     if (itemMethodType) {
                         return getTypeOfIndexedObjectOrClass(node, concreteSubtype, usage).type;
                     }
@@ -4725,9 +4743,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);
+                            }
                         }
                     });
                 }
@@ -4967,7 +4995,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
                 32 /* DisallowParamSpec */ |
                 64 /* DisallowTypeVarTuple */ |
-                1048576 /* AllowRequired */);
+                1048576 /* AllowRequired */ |
+                16384 /* EnforceTypeVarVarianceConsistency */);
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
@@ -6277,7 +6306,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 */: {
@@ -6463,7 +6492,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);
@@ -6548,7 +6577,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return returnType;
                     }
                     else {
-                        const memberType = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__')) === null || _d === void 0 ? void 0 : _d.type;
+                        const memberType = (_e = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
+                        /* usage */ undefined, 
+                        /* 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);
@@ -6563,7 +6594,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({
@@ -6600,7 +6631,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);
@@ -7047,7 +7078,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;
@@ -7131,7 +7162,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) &&
@@ -7707,7 +7741,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);
@@ -10486,7 +10537,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         !ParseTreeUtils.isNodeContainedWithin(errorNode, firstParamTypeAnnotation)) {
                         const annotationType = getTypeOfAnnotation(firstParamTypeAnnotation, {
                             associateTypeVarsWithScope: true,
-                            disallowRecursiveTypeAlias: true,
                         });
                         if (!(0, types_1.isTypeVar)(annotationType) || !annotationType.details.isSynthesizedSelf) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeWithTypedSelfOrCls(), errorNode);
@@ -11145,11 +11195,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // can be specialized.
                         typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
                     }
-                    if (typeAliasTypeVar.details.illegalRecursionDetected) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveIndirect().format({
-                            name: typeAliasNameNode.value,
-                        }), node.leftExpression);
-                    }
                 }
             }
         }
@@ -11235,11 +11280,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Set the resulting type to the boundType of the original type alias
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
-        if (typeAliasTypeVar.details.illegalRecursionDetected) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveIndirect().format({
-                name: node.name.value,
-            }), node.name);
-        }
         writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
@@ -12437,7 +12477,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionType.details.declaredReturnType = types_1.UnknownType.create();
             const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
                 associateTypeVarsWithScope: true,
-                disallowRecursiveTypeAlias: true,
             });
             functionType.details.declaredReturnType = returnType;
         }
@@ -13609,7 +13648,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 annotationNode === annotationParent.returnTypeAnnotation) {
                 getTypeOfAnnotation(annotationNode, {
                     associateTypeVarsWithScope: true,
-                    disallowRecursiveTypeAlias: true,
                 });
                 return;
             }
@@ -15001,8 +15039,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) {
@@ -15085,15 +15128,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
                     const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* DoNotSpecialize */);
                     const callType = baseTypeResult.type;
-                    if ((0, types_1.isInstantiableClass)(callType) &&
-                        types_1.ClassType.isBuiltIn(callType, [
-                            'TypeVar',
-                            'ParamSpec',
-                            'TypeVarTuple',
-                            'TypedDict',
-                            'NamedTuple',
-                            'NewType',
-                        ])) {
+                    const exemptBuiltins = [
+                        'TypeVar',
+                        'ParamSpec',
+                        'TypeVarTuple',
+                        'TypedDict',
+                        'NamedTuple',
+                        'NewType',
+                    ];
+                    if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, exemptBuiltins)) {
+                        isUnambiguousType = true;
+                    }
+                    else if ((0, types_1.isFunction)(callType) &&
+                        exemptBuiltins.some((name) => callType.details.builtInName === name)) {
                         isUnambiguousType = true;
                     }
                 }
@@ -15320,6 +15367,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?
@@ -16783,6 +16836,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
             return true;
         }
+        // Sort the subtypes so we have a deterministic order for unions.
+        let sortedSrcTypes = (0, typeUtils_1.sortTypes)(srcType.subtypes);
         // Handle the case where the source and dest are both unions. Try
         // to eliminate as many exact type matches between the src and dest.
         if ((0, types_1.isUnion)(destType)) {
@@ -16797,8 +16852,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
             const remainingDestSubtypes = [];
-            let remainingSrcSubtypes = [...srcType.subtypes];
-            let isIncompatible = false;
+            let remainingSrcSubtypes = sortedSrcTypes;
+            let canUseFastPath = true;
             // First attempt to match all of the non-generic types in the dest
             // to non-generic types in the source.
             destType.subtypes.forEach((destSubtype) => {
@@ -16817,7 +16872,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // For all remaining source subtypes, attempt to find a dest subtype
             // whose primary type matches.
-            (0, typeUtils_1.sortTypes)(remainingSrcSubtypes).forEach((srcSubtype) => {
+            remainingSrcSubtypes.forEach((srcSubtype) => {
                 const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => {
                     if ((0, types_1.isClass)(srcSubtype) &&
                         (0, types_1.isClass)(destSubtype) &&
@@ -16834,7 +16889,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 if (destTypeIndex >= 0) {
                     if (!assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                        isIncompatible = true;
+                        canUseFastPath = false;
                     }
                     remainingDestSubtypes.splice(destTypeIndex, 1);
                     remainingSrcSubtypes = remainingSrcSubtypes.filter((t) => t !== srcSubtype);
@@ -16842,11 +16897,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // If there is are remaining dest subtypes and they're all type variables,
             // attempt to assign the remaining source subtypes to them.
-            if (!isIncompatible && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
+            if (canUseFastPath && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
                 const isReversed = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
                 const effectiveDestSubtypes = isReversed ? remainingSrcSubtypes : remainingDestSubtypes;
                 if (effectiveDestSubtypes.length === 0 || effectiveDestSubtypes.some((t) => !(0, types_1.isTypeVar)(t))) {
-                    isIncompatible = true;
+                    canUseFastPath = false;
+                    // We can avoid checking the source subtypes that have already been checked.
+                    sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingDestSubtypes.length === remainingSrcSubtypes.length) {
                     // If the number of remaining source subtypes is the same as the number
@@ -16854,9 +16911,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingDestSubtypes.forEach((destSubtype, index) => {
                         const srcSubtype = remainingSrcSubtypes[index];
                         if (!assignType(destSubtype, srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                            isIncompatible = true;
+                            canUseFastPath = false;
                         }
                     });
+                    // We can avoid checking the source subtypes that have already been checked.
+                    sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingSrcSubtypes.length === 0) {
                     if ((flags & 1024 /* PopulatingExpectedType */) !== 0) {
@@ -16870,24 +16929,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // If we've assigned all of the source subtypes but one or more dest
                     // TypeVars have gone unmatched, treat this as success.
-                    return true;
                 }
                 else {
                     // Try to assign a union of the remaining source types to
                     // the first destination TypeVar.
                     if (!assignType(isReversed ? (0, types_1.combineTypes)(remainingDestSubtypes) : remainingDestSubtypes[0], isReversed ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                        isIncompatible = true;
+                        canUseFastPath = false;
                     }
                 }
             }
-            if (!isIncompatible) {
+            if (canUseFastPath) {
                 return true;
             }
         }
-        // For union sources, all of the types need to be assignable to the dest.
         let isIncompatible = false;
-        // Sort the subtypes so we have a deterministic order for unions.
-        (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex, allSubtypes) => {
+        sortedSrcTypes.forEach((subtype) => {
             if (isIncompatible) {
                 return;
             }
@@ -16897,11 +16953,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
                 let isSubtypeSubsumed = false;
-                allSubtypes.forEach((innerSubtype, innerSubtypeIndex) => {
-                    if (isSubtypeSubsumed || subtypeIndex === innerSubtypeIndex || (0, types_1.isAnyOrUnknown)(innerSubtype)) {
-                        return;
-                    }
-                    if (isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
+                srcType.subtypes.forEach((innerSubtype) => {
+                    if (!isSubtypeSubsumed &&
+                        !(0, types_1.isTypeSame)(innerSubtype, subtype) &&
+                        !(0, types_1.isAnyOrUnknown)(innerSubtype) &&
+                        isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
                         isSubtypeSubsumed = true;
                     }
                 });
@@ -16911,8 +16967,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncompatible = true;
                 }
             }
-        }, 
-        /* sortSubtypes */ true);
+        }, /* sortSubtypes */ true);
         if (isIncompatible) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
                 sourceType: printType(srcType),
@@ -17134,6 +17189,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;
             };
@@ -17171,6 +17227,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;
             };
@@ -17195,7 +17252,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) {
@@ -17908,12 +17965,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) {