@zzzen/pyright-internal 1.2.0-dev.20231029 → 1.2.0-dev.20231112

package/dist/analyzer/analyzerFileInfo.d.ts

@@ -37,6 +37,7 @@ export interface AnalyzerFileInfo {
     isStubFile: boolean;
     isTypingStubFile: boolean;
     isTypingExtensionsStubFile: boolean;
+    isTypeshedStubFile: boolean;
     isBuiltInStubFile: boolean;
     isInPyTypedPackage: boolean;
     ipythonMode: IPythonMode;

package/dist/analyzer/analyzerFileInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAAwD;AAqDxD,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,IAAI,6BAAa,CAAC,KAAK,EAAE;QACpE,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}
+{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAAwD;AAsDxD,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,IAAI,6BAAa,CAAC,KAAK,EAAE;QACpE,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}

package/dist/analyzer/checker.js

@@ -46,6 +46,7 @@ const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constructors_1 = require("./constructors");
 const declaration_1 = require("./declaration");
 const declarationUtils_1 = require("./declarationUtils");
 const deprecatedSymbols_1 = require("./deprecatedSymbols");
@@ -176,7 +177,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
-            this._validateConstructorConsistency(classTypeResult.classType);
+            this._validateConstructorConsistency(classTypeResult.classType, node.name);
             this._validateFinalMemberOverrides(classTypeResult.classType);
             this._validateInstanceVariableInitialization(node, classTypeResult.classType);
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
@@ -195,7 +196,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitFunction(node) {
-        var _a;
+        var _a, _b;
         if (node.typeParameters) {
             this.walk(node.typeParameters);
         }
@@ -210,9 +211,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Track whether we have seen a *args: P.args parameter. Named
             // parameters after this need to be flagged as an error.
             let sawParamSpecArgs = false;
+            const keywordNames = new Set();
+            const paramDetails = (0, parameterUtils_1.getParameterListDetails)(functionTypeResult.functionType);
             // Report any unknown or missing parameter types.
             node.parameters.forEach((param, index) => {
                 if (param.name) {
+                    if (param.category === 0 /* Simple */ && index >= paramDetails.positionOnlyParamCount) {
+                        keywordNames.add(param.name.value);
+                    }
                     // Determine whether this is a P.args parameter.
                     if (param.category === 1 /* ArgsList */) {
                         const annotationExpr = param.typeAnnotation || param.typeAnnotationComment;
@@ -270,6 +276,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             });
+            // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
+            if (paramDetails.hasUnpackedTypedDict) {
+                const kwargsIndex = functionTypeResult.functionType.details.parameters.length - 1;
+                const kwargsType = types_1.FunctionType.getEffectiveParameterType(functionTypeResult.functionType, kwargsIndex);
+                if ((0, types_1.isClass)(kwargsType) && kwargsType.details.typedDictEntries) {
+                    const overlappingEntries = new Set();
+                    kwargsType.details.typedDictEntries.forEach((_, name) => {
+                        if (keywordNames.has(name)) {
+                            overlappingEntries.add(name);
+                        }
+                    });
+                    if (overlappingEntries.size > 0) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overlappingKeywordArgs().format({
+                            names: [...overlappingEntries.values()].join(', '),
+                        }), (_a = node.parameters[kwargsIndex].typeAnnotation) !== null && _a !== void 0 ? _a : node.parameters[kwargsIndex]);
+                    }
+                }
+            }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
             const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
                 if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
@@ -284,7 +308,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // If this is a stub, ensure that the return type is specified.
             if (this._fileInfo.isStubFile) {
-                const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+                const returnAnnotation = node.returnTypeAnnotation || ((_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation);
                 if (!returnAnnotation) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
                 }
@@ -514,7 +538,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         else {
             // There is no return expression, so "None" is assumed.
-            returnTypeResult = { type: types_1.NoneType.createInstance() };
+            returnTypeResult = { type: this._evaluator.getNoneType() };
         }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
@@ -591,7 +615,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         const yieldTypeResult = node.expression
             ? this._evaluator.getTypeResult(node.expression)
-            : { type: types_1.NoneType.createInstance() };
+            : { type: this._evaluator.getNoneType() };
         this._validateYieldType(node, (_a = yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.expectedTypeDiagAddendum);
         return true;
     }
@@ -633,7 +657,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
                     subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, types_1.isNoneInstance)(subtype)) {
+                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
                         if ((0, types_1.isClass)(subtype)) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
                                 diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
@@ -1077,7 +1101,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = this._evaluator.getTypeOfMagicMethodReturn(expandedSubtype, [], '__bool__', node, 
+            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
             /* inferenceContext */ undefined);
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
@@ -1252,7 +1276,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // operation have overlapping types.
     _validateComparisonTypesForIsOperator(node) {
         const rightType = this._evaluator.getType(node.rightExpression);
-        if (!rightType || !(0, types_1.isNoneInstance)(rightType)) {
+        if (!rightType || !(0, typeUtils_1.isNoneInstance)(rightType)) {
             return;
         }
         const leftType = this._evaluator.getType(node.leftExpression);
@@ -1262,7 +1286,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let foundMatchForNone = false;
         (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-            if (this._evaluator.assignType(subtype, types_1.NoneType.createInstance())) {
+            if (this._evaluator.assignType(subtype, this._evaluator.getNoneType())) {
                 foundMatchForNone = true;
             }
         });
@@ -1359,7 +1383,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType);
         }
-        if ((0, types_1.isNoneInstance)(leftType) || (0, types_1.isNoneInstance)(rightType)) {
+        if ((0, typeUtils_1.isNoneInstance)(leftType) || (0, typeUtils_1.isNoneInstance)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType);
         }
         const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloadedFunction)(leftType);
@@ -1468,7 +1492,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether the specified type is one that should trigger
     // an "unused" value diagnostic.
     _isTypeValidForUnusedValueTest(type) {
-        return !(0, types_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
+        return !(0, typeUtils_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
     }
     // Verifies that each local type variable is used more than once.
     _validateFunctionTypeVarUsage(node, functionTypeResult) {
@@ -2638,22 +2662,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 case 1 /* Unknown */:
                 case 0 /* Unbound */:
                     break;
-                case 7 /* Class */:
-                    // If it's a class, make sure that it has not been given explicit
-                    // type arguments. This will result in a TypeError exception.
-                    if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
+                case 6 /* Class */:
+                    if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                        isSupported = false;
+                    }
+                    else if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
+                        // If it's a class, make sure that it has not been given explicit
+                        // type arguments. This will result in a TypeError exception.
                         isSupported = false;
                     }
                     break;
-                case 3 /* None */:
-                    isSupported = types_1.TypeBase.isInstantiable(subtype);
-                    break;
-                case 5 /* Function */:
+                case 4 /* Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
                         isSupported = false;
                     }
                     break;
-                case 9 /* Union */:
+                case 8 /* Union */:
                     isSupported = this._isTypeSupportedTypeForIsInstance(subtype, isInstanceCheck);
                     break;
                 default:
@@ -3105,14 +3129,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
             const declaredReturnType = functionType.details.declaredReturnType;
             if (returnAnnotation && declaredReturnType) {
-                if (!(0, types_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
+                if (!(0, typeUtils_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), returnAnnotation);
                 }
             }
             else {
                 const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
                 if (!(0, types_1.isNever)(inferredReturnType) &&
-                    !(0, types_1.isNoneInstance)(inferredReturnType) &&
+                    !(0, typeUtils_1.isNoneInstance)(inferredReturnType) &&
                     !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), node.name);
                 }
@@ -3161,7 +3185,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // type doesn't allow it. Skip this check for abstract methods.
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     // If the declared type isn't compatible with 'None', flag an error.
-                    if (!this._evaluator.assignType(declaredReturnType, types_1.NoneType.createInstance(), diagAddendum)) {
+                    if (!this._evaluator.assignType(declaredReturnType, this._evaluator.getNoneType(), diagAddendum)) {
                         // If the function consists entirely of "...", assume that it's
                         // an abstract method or a protocol method and don't require that
                         // the return type matches. This check can also be skipped for an overload.
@@ -3289,7 +3313,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.ClassType.isDataClass(classType)) {
             return;
         }
-        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 32 /* DeclaredTypesOnly */);
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 64 /* DeclaredTypesOnly */);
         // If there's no __post_init__ method, there's nothing to check.
         if (!postInitMember) {
             return;
@@ -3603,35 +3627,34 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     // Validates that the __init__ and __new__ method signatures are consistent.
-    _validateConstructorConsistency(classType) {
-        const initMember = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
-        const newMember = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
-        if (!initMember || !newMember || !(0, types_1.isClass)(initMember.classType) || !(0, types_1.isClass)(newMember.classType)) {
+    _validateConstructorConsistency(classType, errorNode) {
+        // If the class has a custom metaclass with a __call__ method, skip this check.
+        const callMethodResult = (0, constructors_1.getBoundCallMethod)(this._evaluator, errorNode, classType);
+        if (callMethodResult) {
             return;
         }
-        // If both the __new__ and __init__ come from subclasses, don't bother
-        // checking for this class.
-        if (!types_1.ClassType.isSameGenericClass(newMember.classType, classType) &&
-            !types_1.ClassType.isSameGenericClass(initMember.classType, classType)) {
+        const newMethodResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, errorNode, classType);
+        if (!newMethodResult ||
+            newMethodResult.typeErrors ||
+            !newMethodResult.classType ||
+            !(0, types_1.isClass)(newMethodResult.classType)) {
             return;
         }
-        // If the class that provides the __new__ method has a custom metaclass with a
-        // __call__ method, skip this check.
-        const metaclass = newMember.classType.details.effectiveMetaclass;
-        if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
-            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 64 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
-            if (callMethod) {
-                return;
-            }
+        const initMethodResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, errorNode, types_1.ClassType.cloneAsInstance(classType));
+        if (!initMethodResult ||
+            initMethodResult.typeErrors ||
+            !initMethodResult.classType ||
+            !(0, types_1.isClass)(initMethodResult.classType)) {
+            return;
         }
-        let newMemberType = this._evaluator.getTypeOfMember(newMember);
-        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
+        // If both the __new__ and __init__ come from subclasses, don't bother
+        // checking for this class.
+        if (!types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType) &&
+            !types_1.ClassType.isSameGenericClass(newMethodResult.classType, classType)) {
             return;
         }
-        newMemberType = this._evaluator.bindFunctionToClassOrObject(classType, newMemberType, 
-        /* memberClass */ undefined, 
-        /* treatConstructorAsClassMember */ true);
-        if (!newMemberType) {
+        let newMemberType = newMethodResult.type;
+        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
             return;
         }
         if ((0, types_1.isOverloadedFunction)(newMemberType)) {
@@ -3641,14 +3664,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
         }
-        let initMemberType = this._evaluator.getTypeOfMember(initMember);
+        let initMemberType = initMethodResult.type;
         if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloadedFunction)(initMemberType)) {
             return;
         }
-        initMemberType = this._evaluator.bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), initMemberType);
-        if (!initMemberType) {
-            return;
-        }
         if ((0, types_1.isOverloadedFunction)(initMemberType)) {
             // Find the implementation, not the overloaded signatures.
             initMemberType = types_1.OverloadedFunctionType.getImplementation(initMemberType);
@@ -3656,9 +3675,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
         }
-        if (!(0, types_1.isFunction)(initMemberType) || !(0, types_1.isFunction)(newMemberType)) {
-            return;
-        }
         // If either of the functions has a default parameter signature
         // (* args: Any, ** kwargs: Any), don't proceed with the check.
         if (types_1.FunctionType.hasDefaultParameters(initMemberType) || types_1.FunctionType.hasDefaultParameters(newMemberType)) {
@@ -3681,9 +3697,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */)) {
-            const displayOnInit = types_1.ClassType.isSameGenericClass(initMember.classType, classType);
-            const initDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(initMember.symbol);
-            const newDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(newMember.symbol);
+            const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
+            const initDecl = initMemberType.details.declaration;
+            const newDecl = newMemberType.details.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
                 const mainDeclNode = mainDecl.node.nodeType === 28 /* Function */ ? mainDecl.node.name : mainDecl.node;
@@ -3697,14 +3713,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     type: newSignature,
                 }));
                 const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInconsistentConstructor, diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor, localize_1.Localizer.Diagnostic.constructorParametersMismatch().format({
-                    classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMember.classType : newMember.classType)),
+                    classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMethodResult.classType : newMethodResult.classType)),
                 }) + diagAddendum.getString(), mainDeclNode);
                 if (diagnostic) {
                     const secondaryDecl = displayOnInit ? newDecl : initDecl;
                     diagnostic.addRelatedInfo((displayOnInit
                         ? localize_1.Localizer.DiagnosticAddendum.newMethodLocation()
                         : localize_1.Localizer.DiagnosticAddendum.initMethodLocation()).format({
-                        type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMember.classType : initMember.classType)),
+                        type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMethodResult.classType : initMethodResult.classType)),
                     }), secondaryDecl.path, secondaryDecl.range);
                 }
             }
@@ -3973,7 +3989,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateOverrideDecoratorPresent(symbol, overrideType, baseMember) {
-        var _a;
         // Skip this check if disabled.
         if (this._fileInfo.diagnosticRuleSet.reportImplicitOverride === 'none') {
             return;
@@ -3986,12 +4001,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            const fgetSymbol = overrideType.details.fields.get('fget');
-            if (fgetSymbol) {
-                const fgetType = (_a = this._evaluator.getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (fgetType && (0, types_1.isFunction)(fgetType)) {
-                    overrideFunction = fgetType;
-                }
+            if (overrideType.fgetFunction) {
+                overrideFunction = overrideType.fgetFunction;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4016,7 +4027,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
     _validateOverrideDecoratorNotPresent(symbol, overrideType) {
-        var _a;
         let overrideFunction;
         if ((0, types_1.isFunction)(overrideType)) {
             overrideFunction = overrideType;
@@ -4025,12 +4035,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            const fgetSymbol = overrideType.details.fields.get('fget');
-            if (fgetSymbol) {
-                const fgetType = (_a = this._evaluator.getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (fgetType && (0, types_1.isFunction)(fgetType)) {
-                    overrideFunction = fgetType;
-                }
+            if (overrideType.fgetFunction) {
+                overrideFunction = overrideType.fgetFunction;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4064,8 +4070,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const baseClass = baseClassAndSymbol.classType;
-        const childClassSelf = (0, typeUtils_1.selfSpecializeClass)(childClassType);
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, types_1.ClassType.cloneAsInstance(childClassSelf));
+        const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, childClassSelf);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
@@ -4147,16 +4154,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else {
-                const basePropFields = baseType.details.fields;
-                const subclassPropFields = overrideType.details.fields;
                 const baseClassType = baseClass;
-                ['fget', 'fset', 'fdel'].forEach((methodName) => {
+                const propMethodInfo = [
+                    ['fget', (c) => c.fgetFunction],
+                    ['fset', (c) => c.fsetFunction],
+                    ['fdel', (c) => c.fdelFunction],
+                ];
+                propMethodInfo.forEach((info) => {
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    const baseClassPropMethod = basePropFields.get(methodName);
-                    const subclassPropMethod = subclassPropFields.get(methodName);
+                    const [methodName, methodAccessor] = info;
+                    const baseClassPropMethod = methodAccessor(baseType);
+                    const subclassPropMethod = methodAccessor(overrideType);
                     // Is the method present on the base class but missing in the subclass?
                     if (baseClassPropMethod) {
-                        const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassPropMethod), baseClassType);
+                        const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType);
                         if ((0, types_1.isFunction)(baseClassMethodType)) {
                             if (!subclassPropMethod) {
                                 // The method is missing.
@@ -4176,7 +4187,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 }
                             }
                             else {
-                                const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(subclassPropMethod), childClassType);
+                                const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
                                 if ((0, types_1.isFunction)(subclassMethodType)) {
                                     if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
@@ -4290,7 +4301,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Performs checks on a function that is located within a class
     // and has been determined not to be a property accessor.
     _validateMethod(node, functionType, classNode) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
         const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
         if (node.name && classType) {
@@ -4307,32 +4318,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // __new__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 ||
                 !node.parameters[0].name ||
-                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs'].some((name) => node.parameters[0].name.value === name)) {
+                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.parameters[0].name.value === name)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
             }
             if (classType) {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
             }
         }
-        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '__init_subclass__') {
-            // __init_subclass__ overrides should have a "cls" parameter.
-            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.initSubclassClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
-            }
-            if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
-            }
-        }
-        else if (((_c = node.name) === null || _c === void 0 ? void 0 : _c.value) === '__class_getitem__') {
-            // __class_getitem__ overrides should have a "cls" parameter.
-            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classGetItemClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
-            }
-            if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
-            }
-        }
-        else if (((_d = node.name) === null || _d === void 0 ? void 0 : _d.value) === '_generate_next_value_') {
+        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '_generate_next_value_') {
             // Skip this check for _generate_next_value_.
         }
         else if (types_1.FunctionType.isStaticMethod(functionType)) {
@@ -4420,7 +4413,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // it could be combined with other classes in a multi-inheritance
         // situation that effectively adds new superclasses that we don't know
         // about statically.
-        let effectiveFlags = 8 /* SkipInstanceVariables */ | 1 /* SkipOriginalClass */;
+        let effectiveFlags = 16 /* SkipInstanceMembers */ | 1 /* SkipOriginalClass */;
         if (types_1.ClassType.isFinal(classType)) {
             effectiveFlags |= 4 /* SkipObjectBaseClass */;
         }
@@ -4593,7 +4586,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
                 /* isAsync */ false, 
-                /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                /* errorNode */ except.typeExpression, 
+                /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         sawUnknownExceptionType = true;