@zzzen/pyright-internal 1.2.0-dev.20230305 → 1.2.0-dev.20230319

package/dist/analyzer/typeEvaluator.js

@@ -253,6 +253,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let strClassType;
     let dictClassType;
     let typedDictClassType;
+    let typedDictPrivateClassType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
@@ -500,7 +501,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             intClassType = getBuiltInType(node, 'int');
             strClassType = getBuiltInType(node, 'str');
             dictClassType = getBuiltInType(node, 'dict');
-            typedDictClassType = getTypingType(node, '_TypedDict');
+            typedDictClassType = getTypingType(node, 'TypedDict');
+            typedDictPrivateClassType = getTypingType(node, '_TypedDict');
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
@@ -703,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) &&
@@ -944,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 */,
         });
@@ -988,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 */;
         }
@@ -1842,7 +1835,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictClassType;
+        return typedDictPrivateClassType;
     }
     function getTupleClassType() {
         return tupleClassType;
@@ -4405,7 +4398,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
                 if (typeArgs[index].typeList) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     typeArgs[index].typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
@@ -4451,7 +4444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
@@ -4538,7 +4531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type: printType(unexpandedSubtype),
                     }), node.baseExpression);
                     // Evaluate the index expressions as though they are type arguments for error-reporting.
-                    getTypeArgs(node, flags, /* isAnnotatedClass */ false, /* hasCustomClassGetItem */ false);
+                    getTypeArgs(node, flags);
                     return types_1.UnknownType.create();
                 }
             }
@@ -4546,10 +4539,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;
                     }
@@ -4593,7 +4593,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.ClassType.isPartiallyEvaluated(concreteSubtype);
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
-                let typeArgs = getTypeArgs(node, flags, isAnnotatedClass, hasCustomClassGetItem || !isGenericClass, isFinalAnnotation, isClassVarAnnotation);
+                // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
+                const supportsTypedDictTypeArg = (0, types_1.isInstantiableClass)(concreteSubtype) &&
+                    types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
+                    !concreteSubtype.aliasName;
+                let typeArgs = getTypeArgs(node, flags, {
+                    isAnnotatedClass,
+                    hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
+                    isFinalAnnotation,
+                    isClassVarAnnotation,
+                    supportsTypedDictTypeArg,
+                });
                 if (!isAnnotatedClass) {
                     typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, node);
                 }
@@ -4945,18 +4955,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
-    function getTypeArgs(node, flags, isAnnotatedClass = false, hasCustomClassGetItem = false, isFinalAnnotation = false, isClassVarAnnotation = false) {
+    function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
-        if (isFinalAnnotation || isClassVarAnnotation) {
+        if ((options === null || options === void 0 ? void 0 : options.isFinalAnnotation) || (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation)) {
             adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
         }
         else {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
                 32 /* DisallowParamSpec */ |
                 64 /* DisallowTypeVarTuple */ |
-                1048576 /* AllowRequired */);
-            if (!isAnnotatedClass) {
+                1048576 /* AllowRequired */ |
+                16384 /* EnforceTypeVarVarianceConsistency */);
+            if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
             adjFlags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
@@ -4967,7 +4978,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If it's a custom __class_getitem__, none of the arguments should be
             // treated as types. If it's an Annotated[a, b, c], only the first index
             // should be treated as a type. The others can be regular (non-type) objects.
-            if (hasCustomClassGetItem || (isAnnotatedClass && argIndex > 0)) {
+            if ((options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) || ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0)) {
                 typeResult = {
                     ...getTypeOfExpression(expr, 32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */ |
@@ -4977,7 +4988,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags);
+                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
             }
             return typeResult;
         };
@@ -5016,7 +5027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeArgs;
     }
-    function getTypeArg(node, flags) {
+    function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags |
             128 /* ExpectingType */ |
@@ -5037,8 +5048,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Set the node's type so it isn't reevaluated later.
             setTypeForNode(node, types_1.UnknownType.create());
         }
+        else if (node.nodeType === 15 /* Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClassType)
+                : undefined;
+            const keyTypeFallback = strClassType && (0, types_1.isInstantiableClass)(strClassType) ? strClassType : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
+            if (node.nodeType === 15 /* Dictionary */) {
+                addError(localize_1.Localizer.Diagnostic.dictInAnnotation(), node);
+            }
             // "Protocol" is not allowed as a type argument.
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
@@ -6023,7 +6048,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
                 // Skip the unknown argument check if we've already checked for __init__.
-                const callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                let callResult;
+                if ((0, constructorTransform_1.hasConstructorTransform)(type)) {
+                    // Use speculative mode if we're going to later apply
+                    // a constructor transform. This allows us to use bidirectional
+                    // type inference for arguments in the transform.
+                    callResult = useSpeculativeMode(errorNode, () => {
+                        return validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                    });
+                }
+                else {
+                    callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                }
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -6238,7 +6274,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
-        const returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
+        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
         /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
             var _a, _b, _c, _d, _e, _f;
             switch (expandedSubtype.category) {
@@ -6257,6 +6293,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return expandedSubtype;
                 }
                 case 5 /* Function */: {
+                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
+                            type: printType(expandedSubtype),
+                        }), errorNode);
+                        argumentErrors = true;
+                        return undefined;
+                    }
                     // The stdlib collections/__init__.pyi stub file defines namedtuple
                     // as a function rather than a class, so we need to check for it here.
                     if (expandedSubtype.details.builtInName === 'namedtuple') {
@@ -6378,6 +6421,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             (0, types_1.isNoneInstance)(subtype)) {
                                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                                         }
+                                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                                            return types_1.FunctionType.cloneAsInstantiable(subtype);
+                                        }
                                         return types_1.AnyType.create();
                                     });
                                 }
@@ -6501,7 +6547,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 = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
+                        /* usage */ undefined, 
+                        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
                         if (memberType) {
                             const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
                             overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
@@ -6562,9 +6610,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return undefined;
         });
+        // If we ended up with a "Never" type because all code paths returned
+        // undefined due to argument errors, transform the result into an Unknown
+        // to avoid subsequent false positives.
+        if (argumentErrors && (0, types_1.isNever)(returnType) && !returnType.isNoReturn) {
+            returnType = types_1.UnknownType.create();
+        }
         return {
             argumentErrors,
-            returnType: (0, types_1.isNever)(returnType) && !returnType.isNoReturn ? undefined : returnType,
+            returnType,
             isTypeIncomplete,
             specializedInitSelfType,
             overloadsUsedForCall,
@@ -8278,8 +8332,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(functionType);
             return functionType;
         }
-        if (node.nodeType === 52 /* Tuple */) {
-            node.expressions.forEach((paramExpr, index) => {
+        if (node.nodeType === 31 /* List */) {
+            node.entries.forEach((paramExpr, index) => {
                 const typeResult = getTypeOfExpressionExpectingType(paramExpr);
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* Simple */,
@@ -10433,7 +10487,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);
@@ -10548,6 +10601,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isParamSpec)(typeArg.type)) {
                         addError(localize_1.Localizer.Diagnostic.paramSpecContext(), typeArg.node);
                     }
+                    else if ((0, types_1.isUnpackedVariadicTypeVar)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), typeArg.node);
+                    }
+                    else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), typeArg.node);
+                    }
                 }
             });
         }
@@ -11086,11 +11145,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);
-                    }
                 }
             }
         }
@@ -11176,11 +11230,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;
     }
@@ -11296,7 +11345,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     argType = (0, types_1.removeUnbound)(argType);
                 }
                 if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
-                    if ((0, types_1.isClass)(argType) && types_1.TypeBase.isInstance(argType) && types_1.ClassType.isBuiltIn(argType, 'type')) {
+                    if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
+                        (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
                         argType =
                             argType.typeArguments && argType.typeArguments.length > 0
                                 ? argType.typeArguments[0]
@@ -11883,6 +11933,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     decoratorCallType.details.builtInName === 'dataclass_transform') {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
+                else if (decoratorCallType.details.name === 'deprecated') {
+                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputClassType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -11912,6 +11966,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // dependency between builtins, typing and _typeshed stubs.
                 return inputClassType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputClassType;
+            }
             if (decoratorType.details.builtInName === 'runtime_checkable') {
                 originalClassType.details.flags |= 32768 /* RuntimeCheckable */;
                 // Don't call getTypeOfDecorator for runtime_checkable. It appears
@@ -12369,7 +12427,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionType.details.declaredReturnType = types_1.UnknownType.create();
             const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
                 associateTypeVarsWithScope: true,
-                disallowRecursiveTypeAlias: true,
             });
             functionType.details.declaredReturnType = returnType;
         }
@@ -12704,6 +12761,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                     return inputFunctionType;
                 }
+                if (decoratorCallType.details.name === 'deprecated') {
+                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputFunctionType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -12719,6 +12780,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (decoratorType.details.builtInName === 'abstractmethod') {
                 return inputFunctionType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputFunctionType;
+            }
             // Handle property setters and deleters.
             if (decoratorNode.expression.nodeType === 35 /* MemberAccess */) {
                 const baseType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
@@ -12828,7 +12893,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         getTypeOfFunction(decl.node);
                     }
                 }
-                const overloadedTypes = [];
+                let overloadedTypes = [];
                 // Look at the previous declaration's type.
                 const prevDecl = decls[declIndex - 1];
                 if (prevDecl.type === 5 /* Function */) {
@@ -12850,6 +12915,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (overloadedTypes.length === 1) {
                     return overloadedTypes[0];
                 }
+                // Apply the implementation's docstring to any overloads that don't
+                // have their own docstrings.
+                const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
+                if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
+                    overloadedTypes = overloadedTypes.map((overload) => {
+                        if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
+                            return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
+                        }
+                        return overload;
+                    });
+                }
                 // Create a new overloaded type that copies the contents of the previous
                 // one and adds a new function.
                 const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
@@ -13522,7 +13598,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 annotationNode === annotationParent.returnTypeAnnotation) {
                 getTypeOfAnnotation(annotationNode, {
                     associateTypeVarsWithScope: true,
-                    disallowRecursiveTypeAlias: true,
                 });
                 return;
             }
@@ -14063,7 +14138,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (firstNonDefaultParam >= 0) {
                 minTypeArgCount = firstNonDefaultParam;
             }
-            if (typeArgCount > typeParameters.length) {
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                        name: classType.aliasName || classType.details.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                return { type: typeArgs[0].inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (typeParameters.length === 0) {
@@ -14147,7 +14233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeArgs && index < typeArgs.length) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
@@ -14333,7 +14419,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const scopeTypeHonorsCodeFlow = scopeType !== 1 /* Function */ && scopeType !== 0 /* ListComprehension */;
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
             // Filter the declarations based on flow reachability.
-            const reachableDecls = symbolWithScope.symbol.getDeclarations().filter((decl) => {
+            const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* Alias */ && decl.type !== 0 /* Intrinsic */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
@@ -14361,7 +14447,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // If none of the declarations are reachable from the current node,
             // search for the symbol in outer scopes.
-            if (reachableDecls.length === 0) {
+            if (!reachableDecl) {
                 if (symbolWithScope.scope.type !== 1 /* Function */) {
                     let nextScopeToSearch = symbolWithScope.scope.parent;
                     const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 3 /* Module */;
@@ -14887,7 +14973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
-        var _a, _b;
+        var _a, _b, _c;
         const resolvedDecl = resolveAliasDeclaration(decl, 
         /* resolveLocalNames */ true, 
         /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
@@ -14903,7 +14989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
                 }
-                else {
+                else if (!loaderActions.implicitImports) {
                     return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
                 }
             }
@@ -14979,17 +15065,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isUnambiguousType = true;
                     }
                 }
+                // Special-case constants, which are treated as unambiguous.
                 if (isFinalVariableDeclaration(resolvedDecl) || resolvedDecl.isConstant) {
                     isUnambiguousType = true;
                 }
+                // Special-case calls to certain built-in type functions.
+                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;
+                    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;
+                    }
+                }
             }
         }
         // If the resolved declaration had no defined type, use the
         // inferred type for this node.
         if (resolvedDecl.type === 2 /* Parameter */) {
-            return (_a = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
+            return (_b = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
                 evaluateTypeOfParameter(resolvedDecl.node);
-            })) === null || _a === void 0 ? void 0 : _a.type;
+            })) === null || _b === void 0 ? void 0 : _b.type;
         }
         if (resolvedDecl.type === 1 /* Variable */ && resolvedDecl.inferredTypeSource) {
             const isTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl) || isPossibleTypeAliasOrTypedDict(resolvedDecl);
@@ -14998,9 +15105,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeSource = isTypeAlias && resolvedDecl.inferredTypeSource.parent
                 ? resolvedDecl.inferredTypeSource.parent
                 : resolvedDecl.inferredTypeSource;
-            let inferredType = (_b = evaluateTypeForSubnode(resolvedDecl.node, () => {
+            let inferredType = (_c = evaluateTypeForSubnode(resolvedDecl.node, () => {
                 evaluateTypesForStatement(typeSource);
-            })) === null || _b === void 0 ? void 0 : _b.type;
+            })) === null || _c === void 0 ? void 0 : _c.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* Name */) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
                 const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
@@ -15114,18 +15221,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
         var _a, _b;
-        // Look in the cache to see if we've computed this already.
-        let cacheEntries = effectiveTypeCache.get(symbol.id);
-        const usageNodeId = usageNode ? usageNode.id : undefined;
-        const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
-        if (cacheEntries) {
-            const result = cacheEntries.get(effectiveTypeCacheKey);
-            if (result) {
-                if (!result.isIncomplete) {
-                    return result;
-                }
-            }
-        }
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
@@ -15150,10 +15245,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
                     isRecursiveDefinition: !declaredType,
                 };
-                addToEffectiveTypeCache(result);
                 return result;
             }
         }
+        // Look in the inferred type cache to see if we've computed this already.
+        let cacheEntries = effectiveTypeCache.get(symbol.id);
+        const usageNodeId = usageNode ? usageNode.id : undefined;
+        const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
+        if (cacheEntries) {
+            const result = cacheEntries.get(effectiveTypeCacheKey);
+            if (result) {
+                if (!result.isIncomplete) {
+                    return result;
+                }
+            }
+        }
         // Infer the type.
         const typesToCombine = [];
         const decls = symbol.getDeclarations();
@@ -16669,6 +16775,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)) {
@@ -16683,8 +16791,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) => {
@@ -16703,7 +16811,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) &&
@@ -16720,7 +16828,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);
@@ -16728,11 +16836,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
@@ -16740,9 +16850,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) {
@@ -16756,24 +16868,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;
             }
@@ -16783,11 +16892,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;
                     }
                 });
@@ -16797,8 +16906,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),