@zzzen/pyright-internal 1.2.0-dev.20230730 → 1.2.0-dev.20230813

package/dist/analyzer/typeEvaluator.js

@@ -157,7 +157,7 @@ const maxRecursiveTypeAliasRecursionCount = 10;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
-const verifyTypeCacheEvaluatorFlags = false;
+const verifyTypeCacheEvaluatorFlags = true;
 // This debugging option prints each expression and its evaluated type.
 const printExpressionTypes = false;
 // The following number is chosen somewhat arbitrarily. We need to cut
@@ -683,6 +683,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    function reportInvalidUseOfPep695TypeAlias(type, node) {
+        var _a;
+        // PEP 695 type aliases cannot be used as instantiable classes.
+        if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasNotAllowed().format({ name: type.typeAliasInfo.name }), node);
+            return true;
+        }
+        return false;
+    }
     function validateTypeIsInstantiable(typeResult, flags, node) {
         var _a;
         // If the type is incomplete, don't log any diagnostics yet.
@@ -772,6 +781,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
                 typeResult = {
                     type: iteratorTypeResult.type,
+                    typeErrors: iterTypeResult.typeErrors,
                     unpackedType: iterType,
                     isIncomplete: iteratorTypeResult.isIncomplete,
                 };
@@ -1450,7 +1460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* DoNotSpecialize */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 16777218 /* MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 16 /* DeclaredTypesOnly */);
@@ -1474,7 +1484,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 24 /* Index */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* DoNotSpecialize */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* IndexBaseDefaults */).type);
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
                     const setItemMember = (0, typeUtils_1.lookUpClassMember)(baseType, '__setitem__');
                     if (setItemMember) {
@@ -2035,7 +2045,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, 16777218 /* MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.leftExpression.nodeType === 38 /* Name */) {
@@ -2492,7 +2502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is the source expression a TypeVar() call?
         if ((0, types_1.isTypeVar)(type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* Call */) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* DoNotSpecialize */).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, 16777218 /* CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
@@ -2523,7 +2533,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 24 /* Index */: {
-                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(target, baseTypeResult, {
                     method: 'set',
                     setType: { type, isIncomplete: isTypeIncomplete },
@@ -2560,8 +2570,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                assignTypeToExpression(target.valueExpression, type, 
-                /* isIncomplete */ false, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
+                assignTypeToExpression(target.valueExpression, type, isTypeIncomplete, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
             case 56 /* Unpack */: {
@@ -2651,14 +2660,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* MemberAccessBaseDefaults */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
                 writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
                 writeTypeCache(node, { type: memberType.type }, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
-                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* DoNotSpecialize */);
+                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
                 writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* None */);
                 break;
@@ -2913,6 +2922,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        if ((flags & 16777216 /* DisallowPep695TypeAlias */) !== 0) {
+            if (reportInvalidUseOfPep695TypeAlias(type, node)) {
+                type = types_1.UnknownType.create();
+            }
+        }
         if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
@@ -2967,10 +2981,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (decl.type === 2 /* Parameter */) {
                             return true;
                         }
-                        // Assume alias declarations are also always safe to narrow.
-                        if (decl.type === 8 /* Alias */) {
-                            return true;
-                        }
                         const declCodeFlowNode = AnalyzerNodeInfo.getFlowNode(decl.node);
                         if (!declCodeFlowNode) {
                             return false;
@@ -3146,7 +3156,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     name: type.typeAliasInfo.name,
                 }), node);
             }
-            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, defaultTypeArgs);
+            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
         }
         return type;
     }
@@ -3254,7 +3264,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
-        const baseTypeFlags = 2 /* DoNotSpecialize */ |
+        const baseTypeFlags = 16777218 /* MemberAccessBaseDefaults */ |
             (flags &
                 (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
@@ -3704,7 +3714,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // to leave the Self type generic (not specialized). We'll also
                 // skip this for __new__ methods because they are not bound
                 // to the class but rather assume the type of the cls argument.
-                const selfClass = bindToType || memberName === '__new__' ? undefined : classType;
+                const selfClass = !!bindToType || memberName === '__new__' ? undefined : classType;
                 const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
                 if (typeResult) {
                     type = typeResult.type;
@@ -4236,7 +4246,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfIndex(node, flags = 0 /* None */) {
-        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* DoNotSpecialize */);
+        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* IndexBaseDefaults */);
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this will generate a runtime exception in Python versions
         // less than 3.10.
@@ -4548,7 +4558,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             aliasTypeArgs.push(typeVarType || types_1.UnknownType.create());
         });
-        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
+        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), baseType.typeAliasInfo.name, baseType.typeAliasInfo.fullName, baseType.typeAliasInfo.typeVarScopeId, baseType.typeAliasInfo.isPep695Syntax, baseType.typeAliasInfo.typeParameters, aliasTypeArgs);
         return { type, node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
@@ -4559,7 +4569,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeAliasIsPep695Syntax, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
@@ -5343,7 +5353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */ | (flags & 4 /* AllowForwardReferences */));
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */ | (flags & 4 /* AllowForwardReferences */));
         }
         const argList = node.arguments.map((arg) => {
             const functionArg = {
@@ -5478,7 +5488,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         function getLambdaType() {
-            return getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+            return getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
         }
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
@@ -5488,7 +5498,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+            typeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */);
         }
         return typeResult;
     }
@@ -7487,13 +7497,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start);
-                    const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
-                    /* typeArguments */ undefined, 
-                    /* isTypeArgumentExplicit */ false);
-                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
-                        unknownIfNotFound: true,
-                    });
+                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
+                        const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
+                        /* typeArguments */ undefined, 
+                        /* isTypeArgumentExplicit */ false);
+                        effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
+                            unknownIfNotFound: true,
+                        });
+                    }
                 }
             }
             else if ((0, types_1.isFunction)(effectiveReturnType)) {
@@ -7708,8 +7719,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             eliminateUnsolvedInUnions = false;
         }
         // We'll leave TypeVars unsolved if the call is a recursive
-        // call to a generic function.
-        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
+        // call to a generic function or if this isn't a callable
+        // return with type parameters that are rescoped from the original
+        // function to the returned callable.
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope)) && !type.details.rescopedTypeParameters;
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
@@ -7775,7 +7788,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useStrictTypeGuardSemantics));
             }
         }
-        specializedReturnType = adjustCallableReturnType(specializedReturnType);
+        specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
@@ -7817,19 +7830,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return [];
     }
-    function adjustCallableReturnType(returnType) {
-        // If the return type includes a generic Callable type, set the type var
-        // scope to a wildcard to allow these type vars to be solved. This won't
-        // work with overloads or unions of callables. It's intended for a
-        // specific use case. We may need to make this more sophisticated in
-        // the future.
+    // If the return type includes a generic Callable type, set the type var
+    // scope to a wildcard to allow these type vars to be solved. This won't
+    // work with overloads or unions of callables. It's intended for a
+    // specific use case. We may need to make this more sophisticated in
+    // the future.
+    // The trackedSignatures parameter supplies a list of function signatures
+    // that were used for the function and the arguments passed to it. This is
+    // important because the callable return value may be called again with
+    // one of these signatures, so we may need to "uniquify" the type parameters
+    // to avoid conflicts.
+    function adjustCallableReturnType(returnType, trackedSignatures) {
         if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
             const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
             // If there are no unsolved type variables, we're done. If there are
             // unsolved type parameters, treat them as though they are rescoped
             // to the callable.
             if (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType);
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType, trackedSignatures);
             }
         }
         return returnType;
@@ -8067,7 +8085,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* AllowMissingTypeArgs */ |
                         8 /* EvaluateStringLiteralAsType */ |
                         32 /* DisallowParamSpec */ |
-                        64 /* DisallowTypeVarTuple */
+                        64 /* DisallowTypeVarTuple */ |
+                        16777216 /* DisallowPep695TypeAlias */
                     : 2 /* DoNotSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
@@ -8638,6 +8657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
+        /* isPep695Syntax */ false, 
         /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
     }
     function getBooleanValue(node) {
@@ -8807,7 +8827,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
                 magicMethodType = (_a = getTypeOfObjectMember(errorNode, concreteSubtype, magicMethodName, 
                 /* usage */ undefined, 
-                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */, subtype)) === null || _a === void 0 ? void 0 : _a.type;
+                /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 1 /* AccessClassMembersOnly */)) === null || _a === void 0 ? void 0 : _a.type;
             }
             else if ((0, types_1.isInstantiableClass)(concreteSubtype)) {
                 magicMethodType = (_b = getTypeOfClassMember(errorNode, concreteSubtype, magicMethodName, 
@@ -10485,7 +10505,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, typeParameters, typeParamNodes) {
+    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, typeParameters, typeParamNodes) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -10535,7 +10555,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
             }), errorNode);
         }
-        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
+        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -10756,6 +10776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
                     const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+                    typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = false;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
                     writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
@@ -10800,7 +10821,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isSpeculativeTypeAlias ||
                         (types_1.TypeBase.isInstantiable(rightHandType) && !(0, types_1.isUnknown)(rightHandType))) {
                         // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression);
+                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
+                        /* isPep695Syntax */ false);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                                 name: typeAliasNameNode.value,
@@ -10841,7 +10863,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     callLeftNode.leftExpression.nodeType === 38 /* Name */)) {
                 // See if this is a call to TypedDict. We want to support
                 // recursive type references in a TypedDict call.
-                const callType = getTypeOfExpression(callLeftNode, 2 /* DoNotSpecialize */).type;
+                const callType = getTypeOfExpression(callLeftNode, 16777218 /* CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
                     return true;
                 }
@@ -10854,7 +10876,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // variables since they use normal variable assignment syntax.
     function getTypeOfTypeAlias(node) {
         var _a;
-        return getTypeOfTypeAliasCommon(node, node.name, node.expression, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
+        return getTypeOfTypeAliasCommon(node, node.name, node.expression, 
+        /* isPep695Syntax */ true, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
             let typeParameters = [];
             if (node.typeParameters) {
                 typeParameters = evaluateTypeParameterList(node.typeParameters);
@@ -10864,7 +10887,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // This function is common to the handling of "type" statements and explicit
     // calls to the TypeAliasType constructor.
-    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, typeParamNodes, getTypeParamCallback) {
+    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, isPep695Syntax, typeParamNodes, getTypeParamCallback) {
         const cachedType = readTypeCache(nameNode, 0 /* None */);
         if (cachedType) {
             return cachedType;
@@ -10876,6 +10899,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeAliasTypeVar.details.recursiveTypeAliasName = nameNode.value;
         const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+        typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = isPep695Syntax;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
         writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
@@ -10897,7 +10921,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, typeParameters, typeParamNodes);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                 name: nameNode.value,
@@ -10993,7 +11017,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
             8192 /* AssociateTypeVarsWithCurrentScope */ |
-            16384 /* EnforceTypeVarVarianceConsistency */;
+            16384 /* EnforceTypeVarVarianceConsistency */ |
+            16777216 /* DisallowPep695TypeAlias */;
         if (fileInfo.isStubFile) {
             exprFlags |= 4 /* AllowForwardReferences */;
         }
@@ -12147,7 +12172,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, typeVarsInReturnType);
         // Note that the type parameters have been rescoped so they are not
         // considered valid for the body of this function.
-        functionType.details.rescopedTypeParameters = rescopedTypeVars;
+        if (rescopedTypeVars.length > 0) {
+            functionType.details.rescopedTypeParameters = rescopedTypeVars;
+        }
     }
     function adjustParameterAnnotatedType(param, type) {
         var _a;
@@ -12292,16 +12319,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function createAsyncFunction(node, functionType) {
+        (0, debug_1.assert)(types_1.FunctionType.isAsync(functionType));
         // Clone the original function and replace its return type with an
-        // Awaitable[<returnType>].
-        const awaitableFunctionType = types_1.FunctionType.clone(functionType);
+        // Awaitable[<returnType>]. Mark the new function as no longer async.
+        const awaitableFunctionType = types_1.FunctionType.cloneWithNewFlags(functionType, functionType.details.flags & ~512 /* Async */);
         if (functionType.details.declaredReturnType) {
             awaitableFunctionType.details.declaredReturnType = createAwaitableReturnType(node, functionType.details.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
-        // Note that the inferred type, once lazily computed, needs to wrap the
-        // resulting type in an awaitable.
-        functionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
-        awaitableFunctionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
+        else {
+            awaitableFunctionType.inferredReturnType = createAwaitableReturnType(node, getFunctionInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+        }
         return awaitableFunctionType;
     }
     function createAwaitableReturnType(node, returnType, isGenerator) {
@@ -13022,14 +13049,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         nodeToEvaluate = parent;
                         continue;
                     }
-                    flags = 2 /* DoNotSpecialize */;
+                    flags = 16777218 /* CallBaseDefaults */;
                     break;
                 }
             }
             else if (parent.nodeType === 24 /* Index */) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
-                    flags = 2 /* DoNotSpecialize */;
+                    flags = 2 /* IndexBaseDefaults */;
                     break;
                 }
             }
@@ -14474,7 +14501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // 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 baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 16777218 /* CallBaseDefaults */);
                     const callType = baseTypeResult.type;
                     const exemptBuiltins = [
                         'TypeVar',
@@ -14530,7 +14557,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.TypeBase.isInstantiable(inferredType) &&
                     !(0, types_1.isUnknown)(inferredType) &&
                     !(0, typeUtils_1.isEllipsisType)(inferredType)) {
-                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node);
+                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
+                    /* isPep695Syntax */ false);
                     isUnambiguousType = true;
                 }
             }
@@ -14957,7 +14985,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type);
         if (specializedReturnType) {
-            return adjustCallableReturnType(specializedReturnType);
+            return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
         }
         if (inferTypeIfNeeded) {
             return getFunctionInferredReturnType(type, args);
@@ -15012,10 +15040,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (returnTypeResult === null || returnTypeResult === void 0 ? void 0 : returnTypeResult.isIncomplete) {
                             isIncomplete = true;
                         }
-                        // Do we need to wrap this in an awaitable?
-                        if (returnType && types_1.FunctionType.isWrapReturnTypeInAwait(type)) {
-                            returnType = createAwaitableReturnType(functionNode, returnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
-                        }
                     }
                 }
             }
@@ -15036,17 +15060,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
-            !types_1.FunctionType.isWrapReturnTypeInAwait(type) &&
             args) {
-            const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
-            if (contextualReturnType) {
-                returnType = contextualReturnType;
+            let hasDecorators = false;
+            let isAsync = false;
+            const declNode = (_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.node;
+            if (declNode) {
+                if (declNode.decorators.length > 0) {
+                    hasDecorators = true;
+                }
+                if (declNode.isAsync) {
+                    isAsync = true;
+                }
+            }
+            // We can't use this technique if decorators or async are used because they
+            // would need to be applied to the inferred return type.
+            if (!hasDecorators && !isAsync) {
+                const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
+                if (contextualReturnType) {
+                    returnType = contextualReturnType;
+                }
             }
         }
         return returnType;
     }
     function getFunctionInferredReturnTypeUsingArguments(type, args) {
-        var _a;
         let contextualReturnType;
         if (!type.details.declaration) {
             return undefined;
@@ -15158,10 +15195,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         if (contextualReturnType) {
             contextualReturnType = (0, types_1.removeUnbound)(contextualReturnType);
-            // Do we need to wrap this in an awaitable?
-            if (types_1.FunctionType.isWrapReturnTypeInAwait(type) && !(0, types_1.isNever)(contextualReturnType)) {
-                contextualReturnType = createAwaitableReturnType(functionNode, contextualReturnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
-            }
             if (!isResultFromCache) {
                 // Cache the resulting type.
                 if (!functionType.functionType.callSiteReturnTypeCache) {
@@ -17080,6 +17113,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* SynthesizedMethod */, effectiveSrcType.details.docString);
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
+                    remainingFunction.details.constructorTypeVarScopeId =
+                        effectiveSrcType.details.constructorTypeVarScopeId;
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
@@ -17178,7 +17213,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParam = assignedType.details.typeParameters[index];
                 const expectedTypeArgType = typeVarContext.getPrimarySignature().getTypeVarType(typeParam);
                 if (expectedTypeArgType) {
-                    if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
+                    if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
                         replacedTypeArg = true;
                         return expectedTypeArgType;
                     }
@@ -17190,6 +17225,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return recursiveReplacement;
                         }
                     }
+                    else if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType)) {
+                        // If the expected type arg contains an Any, we can replace it with
+                        // a version that doesn't contain Any if the replacement doesn't violate
+                        // the variance of the type parameter.
+                        const variance = types_1.TypeVarType.getVariance(typeParam);
+                        const isSubtype = assignType(expectedTypeArgType, typeArg);
+                        const isSupertype = assignType(typeArg, expectedTypeArgType);
+                        if ((variance === 4 /* Contravariant */ || isSubtype) &&
+                            (variance === 3 /* Covariant */ || isSupertype)) {
+                            replacedTypeArg = true;
+                            return expectedTypeArgType;
+                        }
+                    }
                 }
                 return typeArg;
             });
@@ -17312,7 +17360,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* exemptSelfClsParam */ false);
             });
             if (matchIndex < 0) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex }));
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex + 1 }));
                 return false;
             }
             if (matchIndex < previousMatchIndex) {
@@ -17471,7 +17519,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    if (!baseParam.isNameSynthesized) {
+                    if (!baseParam.isNameSynthesized &&
+                        baseParamDetails.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 || '*',