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

package/dist/analyzer/typeEvaluator.js

@@ -3818,7 +3818,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 +4641,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, {
@@ -7654,12 +7656,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) {
@@ -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,7 +7758,21 @@ 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);
@@ -7837,12 +7867,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 +7883,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 +8020,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;
@@ -10563,7 +10611,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 +10620,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) {
@@ -12454,9 +12506,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 +12527,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 +13429,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) };
                 }
@@ -15260,8 +15316,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 +15325,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 +15987,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 +17128,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 +17178,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 +17205,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 +17228,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 +17248,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)) {