@zzzen/pyright-internal 1.2.0-dev.20230723 → 1.2.0-dev.20230806

package/dist/analyzer/typeEvaluator.js

@@ -772,6 +772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
                 typeResult = {
                     type: iteratorTypeResult.type,
+                    typeErrors: iterTypeResult.typeErrors,
                     unpackedType: iterType,
                     isIncomplete: iteratorTypeResult.isIncomplete,
                 };
@@ -2967,10 +2968,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;
@@ -3704,7 +3701,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;
@@ -3818,7 +3815,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // a descriptor protocol, only 'get' operations are allowed. If it's accessed
                         // through the object, all access methods are supported.
                         if (isAccessedThroughObject || usage.method === 'get') {
-                            lookupClass = (0, typeUtils_1.convertToInstance)(concreteSubtype.details.effectiveMetaclass);
+                            lookupClass = types_1.ClassType.cloneAsInstance(concreteSubtype.details.effectiveMetaclass);
                             isAccessedThroughMetaclass = true;
                         }
                         else {
@@ -4641,7 +4638,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 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');
                 // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
-                const supportsTypedDictTypeArg = (0, types_1.isInstantiableClass)(concreteSubtype) &&
+                // This feature is currently experimental.
+                const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
+                    (0, types_1.isInstantiableClass)(concreteSubtype) &&
                     types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
                     !concreteSubtype.aliasName;
                 let typeArgs = getTypeArgs(node, flags, {
@@ -7485,13 +7484,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)) {
@@ -7654,12 +7654,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         });
+        let paramSpecTypeVarContext = [];
         // Handle the assignment of additional arguments that map to a param spec.
         if (matchResults.paramSpecArgList && matchResults.paramSpecTarget) {
-            if (!validateFunctionArgumentsForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, typeCondition)) {
+            const paramSpecArgResult = validateFunctionArgumentsForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, typeCondition);
+            if (paramSpecArgResult.argumentErrors) {
                 argumentErrors = true;
                 argumentMatchScore += 1;
             }
+            paramSpecTypeVarContext = paramSpecArgResult.typeVarContexts;
         }
         else if (type.details.paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
@@ -7703,8 +7706,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),
@@ -7713,17 +7718,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             applyInScopePlaceholders: true,
         });
         specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
+        // If the function includes a ParamSpec and the captured signature(s) includes
+        // generic types, we may need to apply those solved TypeVars.
+        if (paramSpecTypeVarContext.length > 0) {
+            paramSpecTypeVarContext.forEach((paramSpecTypeVarContext) => {
+                if (paramSpecTypeVarContext) {
+                    specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(specializedReturnType, paramSpecTypeVarContext);
+                }
+            });
+        }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
         }
-        // Handle 'TypeGuard' and 'StrictTypeGuard' specially. We'll transform the
-        // return type into a 'bool' object with a type argument that reflects the
-        // narrowed type.
+        // Handle 'TypeGuard' specially. We'll transform the return type into a 'bool'
+        // object with a type argument that reflects the narrowed type.
         if ((0, types_1.isClassInstance)(specializedReturnType) &&
-            types_1.ClassType.isBuiltIn(specializedReturnType, ['TypeGuard', 'StrictTypeGuard']) &&
+            types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeGuard') &&
             specializedReturnType.typeArguments &&
-            specializedReturnType.typeArguments.length > 0) {
+            specializedReturnType.typeArguments.length > 0 &&
+            (0, types_1.isClassInstance)(returnType) &&
+            returnType.typeArguments &&
+            returnType.typeArguments.length > 0) {
             if (boolClassType && (0, types_1.isInstantiableClass)(boolClassType)) {
                 let typeGuardType = specializedReturnType.typeArguments[0];
                 // If the first argument is a simple (non-constrained) TypeVar,
@@ -7742,10 +7758,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ]);
                     }
                 }
-                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, types_1.ClassType.isBuiltIn(specializedReturnType, 'StrictTypeGuard')));
+                let useStrictTypeGuardSemantics = false;
+                if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+                    // Determine the type of the first parameter.
+                    const paramIndex = type.boundToType ? 1 : 0;
+                    if (paramIndex < type.details.parameters.length) {
+                        const paramType = types_1.FunctionType.getEffectiveParameterType(type, paramIndex);
+                        // If the type guard meets the requirements that the first parameter
+                        // type is a proper subtype of the return type, we can use strict
+                        // type guard semantics.
+                        if (assignType(paramType, returnType.typeArguments[0])) {
+                            useStrictTypeGuardSemantics = true;
+                        }
+                    }
+                }
+                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);
         }
@@ -7787,19 +7817,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;
@@ -7837,12 +7872,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0], conditionFilter);
         }
         const filteredSignatureContexts = [];
+        const typeVarContexts = [];
         signatureContexts.forEach((context) => {
             // Use speculative mode to avoid emitting errors or caching types.
             useSpeculativeMode(errorNode, () => {
-                if (validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, context, conditionFilter)) {
+                const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, context, conditionFilter);
+                if (!paramSpecArgResult.argumentErrors) {
                     filteredSignatureContexts.push(context);
                 }
+                (0, collectionUtils_1.appendArray)(typeVarContexts, paramSpecArgResult.typeVarContexts);
             });
         });
         // Copy back any compatible signature contexts if any were compatible.
@@ -7850,109 +7888,121 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destTypeVarContext.copySignatureContexts(filteredSignatureContexts);
         }
         // Evaluate non-speculatively to produce a final result and cache types.
-        return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], conditionFilter);
+        const paramSpecArgResult = validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], conditionFilter);
+        return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
     }
     function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, conditionFilter) {
         var _a;
         const paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
-            return false;
+            return { argumentErrors: true, typeVarContexts: [undefined] };
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
         let reportedArgError = false;
-        // Build a map of all named parameters.
-        const paramMap = new Map();
-        const paramSpecParams = paramSpecType.details.parameters;
-        paramSpecParams.forEach((param) => {
-            if (param.name) {
-                paramMap.set(param.name, param);
-            }
-        });
-        let positionalIndex = 0;
-        let positionalIndexLimit = paramSpecParams.findIndex((paramInfo) => paramInfo.category !== 0 /* Simple */);
-        if (positionalIndexLimit < 0) {
-            positionalIndexLimit = paramSpecParams.length;
-        }
-        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
-        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
-        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         let sawUnpackedListArgument = false;
         let sawUnpackedDictArgument = false;
-        argList.forEach((arg) => {
-            var _a;
-            if (arg.argumentCategory === 0 /* Simple */) {
-                let paramType;
-                if (arg.name) {
-                    const paramInfo = paramMap.get(arg.name.value);
-                    if (paramInfo) {
-                        paramType = paramInfo.type;
-                        paramMap.delete(arg.name.value);
-                    }
-                    else if (kwargsParam) {
-                        paramType = kwargsParam.type;
-                    }
-                    else {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), arg.name || errorNode);
-                        reportedArgError = true;
+        let paramMap = new Map();
+        // We'll use two passes in case there are type variables that depend
+        // on later arguments.
+        const passCount = 2;
+        for (let i = 0; i < passCount; i++) {
+            // Unless we're on the last pass, use speculative mode to suppress
+            // any diagnostics.
+            useSpeculativeMode(i < passCount - 1 ? errorNode : undefined, () => {
+                // Build a map of all named parameters.
+                paramMap = new Map();
+                const paramSpecParams = paramSpecType.details.parameters;
+                paramSpecParams.forEach((param) => {
+                    if (param.name) {
+                        paramMap.set(param.name, param);
                     }
-                }
-                else {
-                    if (positionalIndex < positionalIndexLimit) {
-                        const paramInfo = paramSpecParams[positionalIndex];
-                        paramType = paramInfo.type;
-                        if (paramInfo.name) {
-                            paramMap.delete(paramInfo.name);
+                });
+                let positionalIndex = 0;
+                let positionalIndexLimit = paramSpecParams.findIndex((paramInfo) => paramInfo.category !== 0 /* Simple */);
+                if (positionalIndexLimit < 0) {
+                    positionalIndexLimit = paramSpecParams.length;
+                }
+                const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
+                const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
+                const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+                argList.forEach((arg) => {
+                    var _a;
+                    if (arg.argumentCategory === 0 /* Simple */) {
+                        let paramType;
+                        if (arg.name) {
+                            const paramInfo = paramMap.get(arg.name.value);
+                            if (paramInfo) {
+                                paramType = paramInfo.type;
+                                paramMap.delete(arg.name.value);
+                            }
+                            else if (kwargsParam) {
+                                paramType = kwargsParam.type;
+                            }
+                            else {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), arg.name || errorNode);
+                                reportedArgError = true;
+                            }
+                        }
+                        else {
+                            if (positionalIndex < positionalIndexLimit) {
+                                const paramInfo = paramSpecParams[positionalIndex];
+                                paramType = paramInfo.type;
+                                if (paramInfo.name) {
+                                    paramMap.delete(paramInfo.name);
+                                }
+                            }
+                            else if (argsParam) {
+                                paramType = argsParam.type;
+                            }
+                            else {
+                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramSpecParams.length === 1
+                                    ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                    : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                        expected: paramSpecParams.length,
+                                    }), (_a = arg.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
+                                reportedArgError = true;
+                            }
+                            positionalIndex++;
+                        }
+                        if (paramType) {
+                            const argResult = validateArgType({
+                                paramCategory: 0 /* Simple */,
+                                paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes, 
+                                /* usageOffset */ undefined),
+                                requiresTypeVarMatching: false,
+                                argument: arg,
+                                errorNode: arg.valueExpression || errorNode,
+                            }, srcTypeVarContext, signatureTracker, 
+                            /* functionType */ undefined, { conditionFilter });
+                            if (!argResult.isCompatible) {
+                                reportedArgError = true;
+                            }
                         }
                     }
-                    else if (argsParam) {
-                        paramType = argsParam.type;
+                    else if (arg.argumentCategory === 1 /* UnpackedList */) {
+                        sawUnpackedListArgument = true;
+                        // See if there is an *args parameter.
+                        const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
+                        if (argsParam && paramMap.has(argsParam.name)) {
+                            // TODO - validate args type
+                            paramMap.delete(argsParam.name);
+                        }
                     }
                     else {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramSpecParams.length === 1
-                            ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                            : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                expected: paramSpecParams.length,
-                            }), (_a = arg.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
-                        reportedArgError = true;
-                    }
-                    positionalIndex++;
-                }
-                if (paramType) {
-                    const argResult = validateArgType({
-                        paramCategory: 0 /* Simple */,
-                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes, /* usageOffset */ undefined),
-                        requiresTypeVarMatching: false,
-                        argument: arg,
-                        errorNode: arg.valueExpression || errorNode,
-                    }, srcTypeVarContext, signatureTracker, 
-                    /* functionType */ undefined, { conditionFilter });
-                    if (!argResult.isCompatible) {
-                        reportedArgError = true;
+                        sawUnpackedDictArgument = true;
+                        (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
+                        // See if there is an *kwargs parameter.
+                        const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
+                        if (kwargsParam && paramMap.has(kwargsParam.name)) {
+                            // TODO - validate kwargs type
+                            paramMap.delete(kwargsParam.name);
+                        }
                     }
-                }
-            }
-            else if (arg.argumentCategory === 1 /* UnpackedList */) {
-                sawUnpackedListArgument = true;
-                // See if there is an *args parameter.
-                const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
-                if (argsParam && paramMap.has(argsParam.name)) {
-                    // TODO - validate args type
-                    paramMap.delete(argsParam.name);
-                }
-            }
-            else {
-                sawUnpackedDictArgument = true;
-                (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
-                // See if there is an *kwargs parameter.
-                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
-                if (kwargsParam && paramMap.has(kwargsParam.name)) {
-                    // TODO - validate kwargs type
-                    paramMap.delete(kwargsParam.name);
-                }
-            }
-        });
+                });
+            });
+        }
         // Report any missing parameters.
         if (!reportedArgError) {
             let unassignedParams = Array.from(paramMap.keys());
@@ -7975,7 +8025,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!reportedArgError) {
             (0, typeUtils_1.applySourceContextTypeVarsToSignature)(typeVarContext, srcTypeVarContext);
         }
-        return !reportedArgError;
+        return {
+            argumentErrors: reportedArgError,
+            typeVarContexts: [reportedArgError ? srcTypeVarContext : undefined],
+        };
     }
     function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
         var _a;
@@ -8759,7 +8812,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, 
@@ -10563,7 +10616,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['TypeAlias', { alias: '', module: 'builtins' }],
             ['Concatenate', { alias: '', module: 'builtins' }],
             ['TypeGuard', { alias: '', module: 'builtins' }],
-            ['StrictTypeGuard', { alias: '', module: 'builtins' }],
             ['Unpack', { alias: '', module: 'builtins' }],
             ['Required', { alias: '', module: 'builtins' }],
             ['NotRequired', { alias: '', module: 'builtins' }],
@@ -10573,7 +10625,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['LiteralString', { alias: '', module: 'builtins' }],
             ['ReadOnly', { alias: '', module: 'builtins' }],
         ]);
-        const aliasMapEntry = specialTypes.get(assignedName);
+        let aliasMapEntry = specialTypes.get(assignedName);
+        // Support ReadOnly only as an experimental feature.
+        if (assignedName === 'ReadOnly' &&
+            !AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+            aliasMapEntry = undefined;
+        }
         if (aliasMapEntry) {
             const cachedType = readTypeCache(node, 0 /* None */);
             if (cachedType) {
@@ -12095,7 +12152,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;
@@ -12240,16 +12299,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) {
@@ -12454,9 +12513,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return inferredReturnType ? { type: inferredReturnType, isIncomplete } : undefined;
     }
-    // Determines whether the function consists only of a "raise" statement
-    // and the exception type raised is a NotImplementedError. This is commonly
-    // used for abstract methods that
+    // Determines whether the method consists only of a "raise" statement
+    // and the exception type raised is a NotImplementedError or a subclass
+    // thereof. This is commonly used for abstract methods.
     function methodAlwaysRaisesNotImplemented(functionDecl) {
         if (!functionDecl ||
             !functionDecl.isMethod ||
@@ -12475,7 +12534,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 : (0, types_1.isClassInstance)(raiseType)
                     ? raiseType
                     : undefined;
-            if (!classType || !types_1.ClassType.isBuiltIn(classType, 'NotImplementedError')) {
+            if (!classType || !(0, typeUtils_1.derivesFromStdlibClass)(classType, 'NotImplementedError')) {
                 return false;
             }
         }
@@ -13377,18 +13436,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 'Concatenate': {
                     return { type: createConcatenateType(errorNode, classType, typeArgs) };
                 }
-                case 'TypeGuard':
-                case 'StrictTypeGuard': {
+                case 'TypeGuard': {
                     return { type: createTypeGuardType(errorNode, classType, typeArgs, flags) };
                 }
                 case 'Unpack': {
                     return { type: createUnpackType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Required':
-                case 'NotRequired':
-                case 'ReadOnly': {
+                case 'NotRequired': {
                     return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
+                case 'ReadOnly': {
+                    if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+                        return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
+                    }
+                    break;
+                }
                 case 'Self': {
                     return { type: createSelfType(classType, errorNode, typeArgs) };
                 }
@@ -14901,7 +14964,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);
@@ -14909,7 +14972,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return types_1.UnknownType.create();
     }
     function getFunctionInferredReturnType(type, args) {
-        var _a;
         let returnType;
         let isIncomplete = false;
         let analyzeUnannotatedFunctions = true;
@@ -14956,10 +15018,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));
-                        }
                     }
                 }
             }
@@ -14980,7 +15038,6 @@ 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) {
@@ -14990,7 +15047,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return returnType;
     }
     function getFunctionInferredReturnTypeUsingArguments(type, args) {
-        var _a;
         let contextualReturnType;
         if (!type.details.declaration) {
             return undefined;
@@ -15102,10 +15158,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) {
@@ -15260,8 +15312,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeVarContext = new typeVarContext_1.TypeVarContext();
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
-            var _a;
-            if (!isAssignable || !symbol.isClassMember() || symbol.isIgnoredForProtocolMatch()) {
+            if (!isAssignable || symbol.isIgnoredForProtocolMatch()) {
                 return;
             }
             // Constructor methods are exempt from variance calculations.
@@ -15270,32 +15321,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
             (0, debug_1.assert)(memberInfo !== undefined);
-            let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
-            if (destMemberType) {
-                const srcMemberType = getTypeOfMember(memberInfo);
-                destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
-                // Properties require special processing.
-                if ((0, types_1.isClassInstance)(destMemberType) &&
-                    types_1.ClassType.isPropertyClass(destMemberType) &&
-                    (0, types_1.isClassInstance)(srcMemberType) &&
-                    types_1.ClassType.isPropertyClass(srcMemberType)) {
-                    if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
-                    /* selfTypeVarContext */ undefined, recursionCount)) {
-                        isAssignable = false;
-                    }
+            let destMemberType = getEffectiveTypeOfSymbol(symbol);
+            const srcMemberType = getTypeOfMember(memberInfo);
+            destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+            // Properties require special processing.
+            if ((0, types_1.isClassInstance)(destMemberType) &&
+                types_1.ClassType.isPropertyClass(destMemberType) &&
+                (0, types_1.isClassInstance)(srcMemberType) &&
+                types_1.ClassType.isPropertyClass(srcMemberType)) {
+                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                /* selfTypeVarContext */ undefined, recursionCount)) {
+                    isAssignable = false;
                 }
-                else {
-                    const primaryDecl = symbol.getDeclarations()[0];
+            }
+            else {
+                const primaryDecl = symbol.getDeclarations()[0];
+                let flags = 0 /* Default */;
+                if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ &&
+                    !isFinalVariableDeclaration(primaryDecl) &&
+                    !types_1.ClassType.isFrozenDataClass(destType)) {
                     // Class and instance variables that are mutable need to
-                    // enforce invariance.
-                    const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !isFinalVariableDeclaration(primaryDecl)
-                        ? 1 /* EnforceInvariance */
-                        : 0 /* Default */;
-                    if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
-                    /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                        isAssignable = false;
+                    // enforce invariance. We will exempt variables that are
+                    // private or protected, since these are presumably
+                    // not modifiable outside of the class.
+                    if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
+                        flags |= 1 /* EnforceInvariance */;
                     }
                 }
+                if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                    isAssignable = false;
+                }
             }
         });
         if (!isAssignable) {
@@ -15927,7 +15983,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return !isLiteral;
                 }
             }
-            else if (types_1.ClassType.isBuiltIn(destType, ['TypeGuard', 'StrictTypeGuard'])) {
+            else if (types_1.ClassType.isBuiltIn(destType, 'TypeGuard')) {
                 // All the source to be a "bool".
                 if ((originalFlags & 64 /* AllowBoolTypeGuard */) !== 0) {
                     if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'bool')) {
@@ -17068,7 +17124,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Handle the special case where the return type is a TypeGuard[T].
                     // This should also act as a bool, since that's its type at runtime.
                     if ((0, types_1.isClassInstance)(srcReturnType) &&
-                        types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'StrictTypeGuard']) &&
+                        types_1.ClassType.isBuiltIn(srcReturnType, 'TypeGuard') &&
                         boolClassType &&
                         (0, types_1.isInstantiableClass)(boolClassType)) {
                         if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClassType), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -17118,7 +17174,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParam = assignedType.details.typeParameters[index];
                 const expectedTypeArgType = typeVarContext.getPrimarySignature().getTypeVarType(typeParam);
                 if (expectedTypeArgType) {
-                    if ((0, types_1.isAny)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
+                    if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
                         replacedTypeArg = true;
                         return expectedTypeArgType;
                     }
@@ -17145,12 +17201,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
                 // We can't narrow "Any".
-                if ((0, types_1.isAnyOrUnknown)(declaredType)) {
-                    return declaredType;
+                if ((0, types_1.isAnyOrUnknown)(declaredSubtype)) {
+                    return declaredSubtype;
                 }
                 if (assignType(declaredSubtype, assignedSubtype)) {
                     // If the source is generic and has unspecified type arguments,
-                    // see if we can determine then based on the declared type.
+                    // see if we can determine them based on the declared type.
                     if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
                         const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
                         if (result) {
@@ -17168,6 +17224,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // use the concrete type.
                         return declaredSubtype;
                     }
+                    // If the assigned subtype is Any, stick with the declared type.
+                    if ((0, types_1.isAny)(assignedSubtype)) {
+                        return declaredSubtype;
+                    }
+                    // If the declared type doesn't contain any `Any` but the assigned
+                    // type does, stick with the declared type.
+                    if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
+                        return declaredSubtype;
+                    }
                     return assignedSubtype;
                 }
                 return undefined;
@@ -17179,16 +17244,12 @@ 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 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)) {
+        if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
             return narrowedType;
         }
         else if ((0, types_1.isUnknown)(narrowedType)) {
@@ -17247,7 +17308,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) {
@@ -17406,7 +17467,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 || '*',