@zzzen/pyright-internal 1.2.0-dev.20241215 → 1.2.0-dev.20241222

package/dist/analyzer/checker.js

@@ -203,7 +203,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitFunction(node) {
-        var _a, _b, _c;
         if (node.d.typeParams) {
             this.walk(node.d.typeParams);
         }
@@ -222,14 +221,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const paramDetails = (0, parameterUtils_1.getParamListDetails)(functionTypeResult.functionType);
             // Report any unknown or missing parameter types.
             node.d.params.forEach((param, index) => {
-                var _a;
                 if (param.d.name) {
                     if (param.d.category === 0 /* ParamCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
                         keywordNames.add(param.d.name.d.value);
                     }
                     // Determine whether this is a P.args parameter.
                     if (param.d.category === 1 /* ParamCategory.ArgsList */) {
-                        const annotationExpr = (_a = param.d.annotation) !== null && _a !== void 0 ? _a : param.d.annotationComment;
+                        const annotationExpr = param.d.annotation ?? param.d.annotationComment;
                         if (annotationExpr &&
                             annotationExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                             annotationExpr.d.member.d.value === 'args') {
@@ -248,7 +246,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // Allow unknown and missing param types if the param is named '_'.
                 if (param.d.name && param.d.name.d.value !== '_') {
-                    const paramIndex = functionTypeResult.functionType.shared.parameters.findIndex((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
+                    const paramIndex = functionTypeResult.functionType.shared.parameters.findIndex((p) => p.name === param.d.name?.d.value);
                     if (paramIndex >= 0) {
                         const functionTypeParam = functionTypeResult.functionType.shared.parameters[paramIndex];
                         const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, paramIndex);
@@ -299,7 +297,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (overlappingEntries.size > 0) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overlappingKeywordArgs().format({
                             names: [...overlappingEntries.values()].join(', '),
-                        }), (_a = node.d.params[kwargsIndex].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[kwargsIndex]);
+                        }), node.d.params[kwargsIndex].d.annotation ?? node.d.params[kwargsIndex]);
                     }
                 }
             }
@@ -314,15 +312,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return false;
             });
             if (paramSpecParams.length === 1 && paramSpecParams[0].name) {
-                const paramNode = node.d.params.find((param) => { var _a; return ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === paramSpecParams[0].name; });
-                const annotationNode = (_b = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _b !== void 0 ? _b : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
+                const paramNode = node.d.params.find((param) => param.d.name?.d.value === paramSpecParams[0].name);
+                const annotationNode = paramNode?.d.annotation ?? paramNode?.d.annotationComment;
                 if (annotationNode) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsKwargsUsage(), annotationNode);
                 }
             }
             // If this is a stub, ensure that the return type is specified.
             if (this._fileInfo.isStubFile) {
-                const returnAnnotation = node.d.returnAnnotation || ((_c = node.d.funcAnnotationComment) === null || _c === void 0 ? void 0 : _c.d.returnAnnotation);
+                const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
                 if (!returnAnnotation) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.d.name);
                 }
@@ -407,7 +405,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // This signifies an incomplete stub file that obscures type errors.
         if (this._fileInfo.isStubFile && node.d.name.d.value === '__getattr__') {
             const scope = (0, scopeUtils_1.getScopeForNode)(node);
-            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 4 /* ScopeType.Module */) {
+            if (scope?.type === 4 /* ScopeType.Module */) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.d.name);
             }
         }
@@ -465,13 +463,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitCall(node) {
-        var _a;
         this._validateIsInstanceCall(node);
         this._validateIllegalDefaultParamInitializer(node);
         this._validateStandardCollectionInstantiation(node);
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none' ||
             this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine !== 'none') {
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */) {
+            if (node.parent?.nodeType === 47 /* ParseNodeType.StatementList */) {
                 const isRevealTypeCall = node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && node.d.leftExpr.d.value === 'reveal_type';
                 const returnType = this._evaluator.getType(node);
                 if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
@@ -487,9 +484,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitAwait(node) {
-        var _a;
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none') {
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ && node.d.expr.nodeType === 9 /* ParseNodeType.Call */) {
+            if (node.parent?.nodeType === 47 /* ParseNodeType.StatementList */ && node.d.expr.nodeType === 9 /* ParseNodeType.Call */) {
                 const returnType = this._evaluator.getType(node);
                 if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
@@ -548,7 +544,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitReturn(node) {
-        var _a, _b, _c, _d, _e, _f;
         let returnTypeResult;
         let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
@@ -556,7 +551,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             ? this._evaluator.getDeclaredReturnType(enclosingFunctionNode)
             : undefined;
         if (node.d.expr) {
-            returnTypeResult = (_a = this._evaluator.getTypeResult(node.d.expr)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create() };
+            returnTypeResult = this._evaluator.getTypeResult(node.d.expr) ?? { type: types_1.UnknownType.create() };
         }
         else {
             // There is no return expression, so "None" is assumed.
@@ -564,15 +559,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         returnType = returnTypeResult.type;
         // If this type is a special form, use the special form instead.
-        if ((_b = returnType.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+        if (returnType.props?.specialForm) {
             returnType = returnType.props.specialForm;
         }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
         // at runtime in this case.
-        if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.d.isAsync) && node.d.expr) {
+        if (enclosingFunctionNode?.d.isAsync && node.d.expr) {
             const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
-            if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
+            if (functionDecl?.type === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnInAsyncGenerator(), node.d.expr);
             }
         }
@@ -622,31 +617,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnType),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), (_c = node.d.expr) !== null && _c !== void 0 ? _c : node, (_d = returnTypeResult.expectedTypeDiagAddendum) === null || _d === void 0 ? void 0 : _d.getEffectiveTextRange());
+                        }) + diagAddendum.getString(), node.d.expr ?? node, returnTypeResult.expectedTypeDiagAddendum?.getEffectiveTextRange());
                     }
                 }
             }
             if ((0, types_1.isUnknown)(returnType)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypeUnknown(), (_e = node.d.expr) !== null && _e !== void 0 ? _e : node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypeUnknown(), node.d.expr ?? node);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
-                }), (_f = node.d.expr) !== null && _f !== void 0 ? _f : node);
+                }), node.d.expr ?? node);
             }
         }
         return true;
     }
     visitYield(node) {
-        var _a;
         const yieldTypeResult = node.d.expr
             ? this._evaluator.getTypeResult(node.d.expr)
             : { 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);
+        this._validateYieldType(node, yieldTypeResult?.type ?? types_1.UnknownType.create(), yieldTypeResult?.expectedTypeDiagAddendum);
         return true;
     }
     visitYieldFrom(node) {
-        var _a, _b, _c, _d;
         const yieldFromType = this._evaluator.getType(node.d.expr) || types_1.UnknownType.create();
         let yieldType;
         let sendType;
@@ -656,7 +649,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         else {
             yieldType =
-                (_b = (_a = this._evaluator.getTypeOfIterable({ type: yieldFromType }, /* isAsync */ false, node)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                this._evaluator.getTypeOfIterable({ type: yieldFromType }, /* isAsync */ false, node)?.type ??
+                    types_1.UnknownType.create();
             // Does the iterator return a Generator? If so, get the yield type from it.
             // If the iterator doesn't return a Generator, use the iterator return type
             // directly.
@@ -667,7 +661,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else {
                 yieldType =
-                    (_d = (_c = this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
+                    this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)?.type ??
+                        types_1.UnknownType.create();
             }
         }
         this._validateYieldType(node, yieldType, /* expectedDiagAddendum */ undefined, sendType);
@@ -754,7 +749,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-                if (!(0, types_1.isClassInstance)(subtype) || !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.priv.tupleTypeArgs) || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
+                if (!(0, types_1.isClassInstance)(subtype) || !tupleType?.priv.tupleTypeArgs || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
                     return;
                 }
                 const tupleLength = tupleType.priv.tupleTypeArgs.length;
@@ -940,12 +935,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitMemberAccess(node) {
-        var _a;
         const typeResult = this._evaluator.getTypeResult(node.d.member);
-        const type = (_a = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        const type = typeResult?.type ?? types_1.UnknownType.create();
         const leftExprType = this._evaluator.getType(node.d.leftExpr);
         this._reportDeprecatedUseForType(node.d.member, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.priv.moduleName === 'typing');
-        if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+        if (typeResult?.memberAccessDeprecationInfo) {
             this._reportDeprecatedUseForMemberAccess(node.d.member, typeResult.memberAccessDeprecationInfo);
         }
         this._conditionallyReportPrivateUsage(node.d.member);
@@ -986,11 +980,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitImportFromAs(node) {
-        var _a, _b, _c;
         if (this._fileInfo.isStubFile) {
             return false;
         }
-        const decls = (_a = this._evaluator.getDeclInfoForNameNode(node.d.name)) === null || _a === void 0 ? void 0 : _a.decls;
+        const decls = this._evaluator.getDeclInfoForNameNode(node.d.name)?.decls;
         if (!decls) {
             return false;
         }
@@ -1000,7 +993,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 continue;
             }
             const resolvedAlias = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
-            const resolvedAliasUri = resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.uri;
+            const resolvedAliasUri = resolvedAlias?.uri;
             if (!resolvedAliasUri || !(0, sourceMapper_1.isStubFile)(resolvedAliasUri)) {
                 continue;
             }
@@ -1012,14 +1005,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             break;
         }
         let isImportFromTyping = false;
-        if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
+        if (node.parent?.nodeType === 25 /* ParseNodeType.ImportFrom */) {
             if (node.parent.d.module.d.leadingDots === 0 && node.parent.d.module.d.nameParts.length === 1) {
                 if (node.parent.d.module.d.nameParts[0].d.value === 'typing') {
                     isImportFromTyping = true;
                 }
             }
         }
-        const type = this._evaluator.getType((_c = node.d.alias) !== null && _c !== void 0 ? _c : node.d.name);
+        const type = this._evaluator.getType(node.d.alias ?? node.d.name);
         this._reportDeprecatedUseForType(node.d.name, type, isImportFromTyping);
         return false;
     }
@@ -1037,10 +1030,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitTypeParameter(node) {
-        var _a, _b, _c, _d;
         // Verify that there are no live type variables with the same
         // name in outer scopes.
-        let curNode = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent;
+        let curNode = node.parent?.parent?.parent;
         let foundDuplicate = false;
         while (curNode) {
             const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
@@ -1048,15 +1040,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             }
             if (typeVarScopeNode.nodeType === 10 /* ParseNodeType.Class */) {
-                const classType = (_c = this._evaluator.getTypeOfClass(typeVarScopeNode)) === null || _c === void 0 ? void 0 : _c.classType;
-                if (classType === null || classType === void 0 ? void 0 : classType.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
+                const classType = this._evaluator.getTypeOfClass(typeVarScopeNode)?.classType;
+                if (classType?.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
             }
             else if (typeVarScopeNode.nodeType === 31 /* ParseNodeType.Function */) {
-                const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
-                if (functionType === null || functionType === void 0 ? void 0 : functionType.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
+                const functionType = this._evaluator.getTypeOfFunction(typeVarScopeNode)?.functionType;
+                if (functionType?.shared.typeParams.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
@@ -1144,7 +1136,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isTypeBool = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         this._evaluator.mapSubtypesExpandTypeVars(operandType, /* options */ undefined, (expandedSubtype) => {
-            var _a;
             if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
                 return undefined;
             }
@@ -1153,8 +1144,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = (_a = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
-            /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
+            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
+            /* inferenceContext */ undefined)?.type;
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
             }
@@ -1209,7 +1200,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportUnusedExpression(node) {
-        var _a, _b;
         if (this._fileInfo.diagnosticRuleSet.reportUnusedExpression === 'none') {
             return;
         }
@@ -1235,9 +1225,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (reportAsUnused &&
             this._fileInfo.ipythonMode === sourceFile_1.IPythonMode.CellDocs &&
-            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ &&
+            node.parent?.nodeType === 47 /* ParseNodeType.StatementList */ &&
             node.parent.d.statements[node.parent.d.statements.length - 1] === node &&
-            ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 36 /* ParseNodeType.Module */ &&
+            node.parent.parent?.nodeType === 36 /* ParseNodeType.Module */ &&
             node.parent.parent.d.statements[node.parent.parent.d.statements.length - 1] === node.parent) {
             // Exclude an expression at the end of a notebook cell, as that is treated as
             // the cell's value.
@@ -1465,7 +1455,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // If the function is a generator, validates that its annotated return type
     // is appropriate for a generator.
     _validateGeneratorReturnType(node, functionType) {
-        var _a;
         if (!types_1.FunctionType.isGenerator(functionType)) {
             return;
         }
@@ -1501,7 +1490,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, errorMessage.format({ yieldType: this._evaluator.printType(types_1.AnyType.create()) }) +
-                diagAddendum.getString(), (_a = node.d.returnAnnotation) !== null && _a !== void 0 ? _a : node.d.name);
+                diagAddendum.getString(), node.d.returnAnnotation ?? node.d.name);
         }
     }
     // Determines whether the specified type is one that should trigger
@@ -1532,7 +1521,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         const nameWalker = new ParseTreeUtils.NameNodeWalker((nameNode, subscriptIndex, baseExpression) => {
-            var _a, _b, _c, _d, _e, _f, _g;
             const nameType = this._evaluator.getType(nameNode);
             ``;
             if (nameType && (0, types_1.isTypeVar)(nameType) && !types_1.TypeVarType.isSelf(nameType)) {
@@ -1550,13 +1538,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // exempt it from the check because the type alias may repeat
                         // the TypeVar multiple times.
                         const baseType = this._evaluator.getType(baseExpression);
-                        const aliasInfo = (_a = baseType === null || baseType === void 0 ? void 0 : baseType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-                        if ((aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.shared.typeParams) && subscriptIndex < aliasInfo.shared.typeParams.length) {
+                        const aliasInfo = baseType?.props?.typeAliasInfo;
+                        if (aliasInfo?.shared.typeParams && subscriptIndex < aliasInfo.shared.typeParams.length) {
                             isExempt = true;
                         }
                     }
                     const existingEntry = localTypeVarUsage.get(nameType.shared.name);
-                    const isParamTypeWithEllipsisUsage = ((_b = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.defaultValue) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = curParamNode?.d.defaultValue?.nodeType === 21 /* ParseNodeType.Ellipsis */;
                     if (!existingEntry) {
                         localTypeVarUsage.set(nameType.shared.name, {
                             nodes: [nameNode],
@@ -1564,7 +1552,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
                             returnTypeUsageCount: curParamNode === undefined ? 1 : 0,
-                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_c = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _c === void 0 ? void 0 : _c.d.value : undefined,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? curParamNode?.d.name?.d.value : undefined,
                             isExempt,
                         });
                     }
@@ -1575,7 +1563,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             if (isParamTypeWithEllipsisUsage) {
                                 existingEntry.paramTypeWithEllipsisUsageCount += 1;
                                 if (!existingEntry.paramWithEllipsis) {
-                                    existingEntry.paramWithEllipsis = (_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _d === void 0 ? void 0 : _d.d.value;
+                                    existingEntry.paramWithEllipsis = curParamNode?.d.name?.d.value;
                                 }
                             }
                         }
@@ -1588,7 +1576,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // this constructor method?
                 if (constructorClass && nameType.priv.scopeId === constructorClass.shared.typeVarScopeId) {
                     const existingEntry = classTypeVarUsage.get(nameType.shared.name);
-                    const isParamTypeWithEllipsisUsage = ((_e = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.defaultValue) === null || _e === void 0 ? void 0 : _e.nodeType) === 21 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = curParamNode?.d.defaultValue?.nodeType === 21 /* ParseNodeType.Ellipsis */;
                     const isExempt = !!nameType.shared.isDefaultExplicit;
                     if (!existingEntry) {
                         classTypeVarUsage.set(nameType.shared.name, {
@@ -1597,7 +1585,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
                             returnTypeUsageCount: 0,
-                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_f = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _f === void 0 ? void 0 : _f.d.value : undefined,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? curParamNode?.d.name?.d.value : undefined,
                             isExempt,
                         });
                     }
@@ -1608,7 +1596,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             if (isParamTypeWithEllipsisUsage) {
                                 existingEntry.paramTypeWithEllipsisUsageCount += 1;
                                 if (!existingEntry.paramWithEllipsis) {
-                                    existingEntry.paramWithEllipsis = (_g = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _g === void 0 ? void 0 : _g.d.value;
+                                    existingEntry.paramWithEllipsis = curParamNode?.d.name?.d.value;
                                 }
                             }
                         }
@@ -1642,7 +1630,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         localTypeVarUsage.forEach((usage) => {
-            var _a;
             // Report error for local type variable that appears only once.
             if (usage.nodes.length === 1 && !usage.isExempt) {
                 let altTypeText;
@@ -1690,14 +1677,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
                     name: usage.nodes[0].d.value,
-                    param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
+                    param: usage.paramWithEllipsis ?? '',
                 }) + diag.getString(), usage.nodes[0]);
             }
         });
         // Report error for a class type variable that appears only within
         // constructor parameters that have default values. These may go unsolved.
         classTypeVarUsage.forEach((usage) => {
-            var _a;
             if (usage.paramTypeWithEllipsisUsageCount > 0 &&
                 usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount &&
                 !usage.isExempt) {
@@ -1705,14 +1691,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
                     name: usage.nodes[0].d.value,
-                    param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
+                    param: usage.paramWithEllipsis ?? '',
                 }) + diag.getString(), usage.nodes[0]);
             }
         });
     }
     // Validates that overloads use @staticmethod and @classmethod consistently.
     _validateOverloadAttributeConsistency(node, functionType) {
-        var _a, _b, _c, _d, _e, _f;
         // Don't bother with the check if it's suppressed.
         if (this._fileInfo.diagnosticRuleSet.reportInconsistentOverload === 'none') {
             return;
@@ -1745,12 +1730,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (staticMethodCount > 0 && staticMethodCount < totalMethods) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadStaticMethodInconsistent().format({
                 name: node.d.name.d.value,
-            }), (_c = (_b = (_a = overloads[0]) === null || _a === void 0 ? void 0 : _a.shared.declaration) === null || _b === void 0 ? void 0 : _b.node.d.name) !== null && _c !== void 0 ? _c : node.d.name);
+            }), overloads[0]?.shared.declaration?.node.d.name ?? node.d.name);
         }
         if (classMethodCount > 0 && classMethodCount < totalMethods) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadClassMethodInconsistent().format({
                 name: node.d.name.d.value,
-            }), (_f = (_e = (_d = overloads[0]) === null || _d === void 0 ? void 0 : _d.shared.declaration) === null || _e === void 0 ? void 0 : _e.node.d.name) !== null && _f !== void 0 ? _f : node.d.name);
+            }), overloads[0]?.shared.declaration?.node.d.name ?? node.d.name);
         }
     }
     // Validates that overloads do not overlap with inconsistent return results.
@@ -1795,15 +1780,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // earlier overload. Typeshed stubs contain type: ignore comments on these
     // lines, so it is important for us to report them in the same manner.
     _findNodeForOverload(functionNode, overloadType) {
-        var _a;
-        const decls = (_a = this._evaluator.getDeclInfoForNameNode(functionNode.d.name)) === null || _a === void 0 ? void 0 : _a.decls;
+        const decls = this._evaluator.getDeclInfoForNameNode(functionNode.d.name)?.decls;
         if (!decls) {
             return undefined;
         }
         for (const decl of decls) {
             if (decl.type === 5 /* DeclarationType.Function */) {
                 const functionType = this._evaluator.getTypeOfFunction(decl.node);
-                if ((functionType === null || functionType === void 0 ? void 0 : functionType.functionType) === overloadType) {
+                if (functionType?.functionType === overloadType) {
                     return decl.node;
                 }
             }
@@ -1811,7 +1795,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
-        var _a, _b, _c;
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -1824,14 +1807,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (partialOverlap) {
             flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
-        const functionNode = (_a = functionType.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
+        const functionNode = functionType.shared.declaration?.node;
         if (functionNode) {
             const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode);
             functionType = (0, typeUtils_1.makeTypeVarsBound)(functionType, liveTypeVars);
         }
         // Use the parent node of the declaration in this case so we don't transform
         // function-local type variables into bound type variables.
-        const prevOverloadNode = (_c = (_b = prevOverload.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent;
+        const prevOverloadNode = prevOverload.shared.declaration?.node?.parent;
         if (prevOverloadNode) {
             const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode);
             prevOverload = (0, typeUtils_1.makeTypeVarsBound)(prevOverload, liveTypeVars);
@@ -1845,16 +1828,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // of the same arguments as the overload and return a type that is consistent
     // with the overload's return type.
     _validateOverloadImplementation(overload, implementation, diag) {
-        var _a, _b, _c, _d, _e;
         const constraints = new constraintTracker_1.ConstraintTracker();
         let implBound = implementation;
         let overloadBound = overload;
-        const implNode = (_b = (_a = implementation.shared.declaration) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b.parent;
+        const implNode = implementation.shared.declaration?.node?.parent;
         if (implNode) {
             const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implNode);
             implBound = (0, typeUtils_1.makeTypeVarsBound)(implementation, liveScopeIds);
         }
-        const overloadNode = (_c = overload.shared.declaration) === null || _c === void 0 ? void 0 : _c.node;
+        const overloadNode = overload.shared.declaration?.node;
         if (overloadNode) {
             const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(overloadNode);
             overloadBound = (0, typeUtils_1.makeTypeVarsBound)(overload, liveScopeIds);
@@ -1862,8 +1844,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // First check the parameters to see if they are assignable.
         let isConsistent = this._evaluator.assignType(overloadBound, implBound, diag, constraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 2 /* AssignTypeFlags.Contravariant */ | 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
-        const overloadReturnType = this._evaluator.solveAndApplyConstraints((_d = types_1.FunctionType.getEffectiveReturnType(overloadBound)) !== null && _d !== void 0 ? _d : this._evaluator.getInferredReturnType(overloadBound), constraints);
-        const implReturnType = this._evaluator.solveAndApplyConstraints((_e = types_1.FunctionType.getEffectiveReturnType(implBound)) !== null && _e !== void 0 ? _e : this._evaluator.getInferredReturnType(implBound), constraints);
+        const overloadReturnType = this._evaluator.solveAndApplyConstraints(types_1.FunctionType.getEffectiveReturnType(overloadBound) ?? this._evaluator.getInferredReturnType(overloadBound), constraints);
+        const implReturnType = this._evaluator.solveAndApplyConstraints(types_1.FunctionType.getEffectiveReturnType(implBound) ?? this._evaluator.getInferredReturnType(implBound), constraints);
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
             !this._evaluator.assignType(implReturnType, overloadReturnType, returnDiag.createAddendum(), constraints, 0 /* AssignTypeFlags.Default */)) {
@@ -1871,7 +1853,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 sourceType: this._evaluator.printType(overloadReturnType),
                 destType: this._evaluator.printType(implReturnType),
             }));
-            diag === null || diag === void 0 ? void 0 : diag.addAddendum(returnDiag);
+            diag?.addAddendum(returnDiag);
             isConsistent = false;
         }
         return isConsistent;
@@ -2050,8 +2032,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateSymbolTables() {
-        var _a;
-        const dependentFileInfo = (_a = this._dependentFiles) === null || _a === void 0 ? void 0 : _a.map((p) => AnalyzerNodeInfo.getFileInfo(p.parseTree));
+        const dependentFileInfo = this._dependentFiles?.map((p) => AnalyzerNodeInfo.getFileInfo(p.parseTree));
         for (const scopedNode of this._scopedNodes) {
             const scope = AnalyzerNodeInfo.getScope(scopedNode);
             if (scope) {
@@ -2072,7 +2053,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (const paramList of this._typeParamLists) {
             const typeParamScope = AnalyzerNodeInfo.getScope(paramList);
             for (const param of paramList.d.params) {
-                const symbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.d.name.d.value);
+                const symbol = typeParamScope?.symbolTable.get(param.d.name.d.value);
                 if (!symbol) {
                     // This can happen if the code is unreachable.
                     return;
@@ -2162,7 +2143,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Verify that all overload signatures are assignable to implementation signature.
         types_1.OverloadedType.getOverloads(type).forEach((overload, index) => {
-            var _a, _b, _c, _d;
             const diag = new diagnostic_1.DiagnosticAddendum();
             if (implementation &&
                 (0, types_1.isFunction)(implementation) &&
@@ -2173,7 +2153,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         index: index + 1,
                     }) + diag.getString(), implementation.shared.declaration.node.d.name);
                     if (diagnostic && overload.shared.declaration) {
-                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.shared.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), overload.shared.declaration?.uri ?? primaryDecl.uri, overload.shared.declaration?.range ?? primaryDecl.range);
                     }
                 }
             }
@@ -2212,9 +2192,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         decls.forEach((decl) => {
-            var _a;
             if (decl !== finalImportDecl) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
             }
         });
     }
@@ -2233,8 +2212,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const decls = symbol.getDeclarations();
         decls.forEach((decl) => {
-            var _a;
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
         });
     }
     // If a variable is marked Final, it should receive only one assigned value.
@@ -2246,7 +2224,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let sawFinal = false;
         let sawAssignment = false;
         decls.forEach((decl) => {
-            var _a;
             if (this._evaluator.isFinalVariableDeclaration(decl)) {
                 if (sawFinal) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclaration().format({ name }), decl.node);
@@ -2264,7 +2241,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             // the assignment is within an `__init__` method, so ignore class
                             // scopes here.
                             const classOrFunc = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
-                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 31 /* ParseNodeType.Function */) {
+                            if (classOrFunc?.nodeType === 31 /* ParseNodeType.Function */) {
                                 exemptAssignment = true;
                             }
                         }
@@ -2279,7 +2256,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 reportRedeclaration = true;
             }
             if (reportRedeclaration) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
             }
         });
         // If it's not a stub file, an assignment must be provided.
@@ -2326,7 +2303,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportIncompatibleDeclarations(name, symbol) {
-        var _a, _b, _c, _d;
         // If there's one or more declaration with a declared type,
         // all other declarations should match. The only exception is
         // for functions that have an overload.
@@ -2433,13 +2409,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if (otherDecl.type === 5 /* DeclarationType.Function */) {
-                const primaryType = (_a = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _a === void 0 ? void 0 : _a.type;
+                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl)?.type;
                 let duplicateIsOk = false;
                 // If the return type has not yet been inferred, do so now.
                 if (primaryType && (0, types_1.isFunction)(primaryType)) {
                     this._evaluator.getInferredReturnType(primaryType);
                 }
-                const otherType = (_b = this._evaluator.getTypeForDeclaration(otherDecl)) === null || _b === void 0 ? void 0 : _b.type;
+                const otherType = this._evaluator.getTypeForDeclaration(otherDecl)?.type;
                 const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
                 const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
                 // Allow same-signature overrides in cases where the declarations
@@ -2483,12 +2459,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if (otherDecl.type === 1 /* DeclarationType.Variable */) {
-                const primaryType = (_c = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _c === void 0 ? void 0 : _c.type;
+                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl)?.type;
                 if (otherDecl.typeAnnotationNode) {
                     if (otherDecl.node.nodeType === 38 /* ParseNodeType.Name */) {
                         let duplicateIsOk = false;
                         // It's OK if they both have the same declared type.
-                        const otherType = (_d = this._evaluator.getTypeForDeclaration(otherDecl)) === null || _d === void 0 ? void 0 : _d.type;
+                        const otherType = this._evaluator.getTypeForDeclaration(otherDecl)?.type;
                         if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                             duplicateIsOk = true;
                         }
@@ -2534,7 +2510,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _conditionallyReportUnusedDeclaration(decl, isPrivate) {
-        var _a;
         let diagnosticLevel;
         let nameNode;
         let message;
@@ -2569,7 +2544,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const importFrom = decl.node.parent;
                     // For statements of the form "from y import x as x", don't mark "x" as
                     // unaccessed because it's assumed to be re-exported.
-                    const isReexport = ((_a = decl.node.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) === decl.node.d.name.d.value;
+                    const isReexport = decl.node.d.alias?.d.value === decl.node.d.name.d.value;
                     // If this is a __future__ import, it's OK for the import symbol to be unaccessed.
                     const isFuture = importFrom.d.module.d.nameParts.length === 1 &&
                         importFrom.d.module.d.nameParts[0].d.value === '__future__';
@@ -2793,10 +2768,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-            var _a, _b;
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
-            if (((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, 'TypeAliasType')) {
+            if (subtype.props?.specialForm && types_1.ClassType.isBuiltIn(subtype.props.specialForm, 'TypeAliasType')) {
                 diag.addMessage(localize_1.LocAddendum.typeAliasInstanceCheck());
                 isSupported = false;
                 return;
@@ -2846,7 +2820,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.newTypeClassNotAllowed());
                         isSupported = false;
                     }
-                    else if (((_b = subtype.props) === null || _b === void 0 ? void 0 : _b.specialForm) &&
+                    else if (subtype.props?.specialForm &&
                         (0, types_1.isClassInstance)(subtype.props.specialForm) &&
                         types_1.ClassType.isBuiltIn(subtype.props.specialForm, 'Annotated')) {
                         diag.addMessage(localize_1.LocAddendum.annotatedNotAllowed());
@@ -2927,7 +2901,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportDeprecatedUseForOperation(node, typeResult) {
-        const deprecationInfo = typeResult === null || typeResult === void 0 ? void 0 : typeResult.magicMethodDeprecationInfo;
+        const deprecationInfo = typeResult?.magicMethodDeprecationInfo;
         if (!deprecationInfo) {
             return;
         }
@@ -2937,7 +2911,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }), deprecationInfo.deprecatedMessage);
     }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
-        var _a, _b, _c;
         if (!type) {
             return;
         }
@@ -3044,10 +3017,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedDiagnostic(node, errorMessage, deprecatedMessage);
         }
         if (this._fileInfo.diagnosticRuleSet.deprecateTypingAliases) {
-            const deprecatedForm = (_a = deprecatedSymbols_1.deprecatedAliases.get(node.d.value)) !== null && _a !== void 0 ? _a : deprecatedSymbols_1.deprecatedSpecialForms.get(node.d.value);
+            const deprecatedForm = deprecatedSymbols_1.deprecatedAliases.get(node.d.value) ?? deprecatedSymbols_1.deprecatedSpecialForms.get(node.d.value);
             if (deprecatedForm) {
                 if (((0, types_1.isInstantiableClass)(type) && type.shared.fullName === deprecatedForm.fullName) ||
-                    ((_c = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) === null || _c === void 0 ? void 0 : _c.shared.fullName) === deprecatedForm.fullName) {
+                    type.props?.typeAliasInfo?.shared.fullName === deprecatedForm.fullName) {
                     if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._fileInfo.executionEnvironment.pythonVersion, deprecatedForm.version)) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
                             this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedType().format({
@@ -3122,17 +3095,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _conditionallyReportShadowedImport(node) {
-        var _a, _b;
         if (this._fileInfo.diagnosticRuleSet.reportShadowedImports === 'none') {
             return;
         }
         // Skip this check for relative imports.
         const nodeModule = node.nodeType === 26 /* ParseNodeType.ImportFromAs */
-            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */
-                ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.d.module
+            ? node.parent?.nodeType === 25 /* ParseNodeType.ImportFrom */
+                ? node.parent?.d.module
                 : undefined
             : node.d.module;
-        if (nodeModule === null || nodeModule === void 0 ? void 0 : nodeModule.d.leadingDots) {
+        if (nodeModule?.d.leadingDots) {
             return;
         }
         // Otherwise use the name to determine if a match for a stdlib module.
@@ -3175,7 +3147,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _conditionallyReportPrivateUsage(node) {
-        var _a, _b, _c;
         if (this._fileInfo.diagnosticRuleSet.reportPrivateUsage === 'none') {
             return;
         }
@@ -3184,7 +3155,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Ignore privates in named arguments.
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* ParseNodeType.Argument */ && node.parent.d.name === node) {
+        if (node.parent?.nodeType === 1 /* ParseNodeType.Argument */ && node.parent.d.name === node) {
             return;
         }
         const nameValue = node.d.value;
@@ -3198,8 +3169,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Get the declarations for this name node, but filter out
         // any variable declarations that are bound using nonlocal
         // or global explicit bindings.
-        const declarations = (_c = (_b = this._evaluator
-            .getDeclInfoForNameNode(node)) === null || _b === void 0 ? void 0 : _b.decls) === null || _c === void 0 ? void 0 : _c.filter((decl) => decl.type !== 1 /* DeclarationType.Variable */ || !decl.isExplicitBinding);
+        const declarations = this._evaluator
+            .getDeclInfoForNameNode(node)
+            ?.decls?.filter((decl) => decl.type !== 1 /* DeclarationType.Variable */ || !decl.isExplicitBinding);
         let primaryDeclaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : undefined;
         if (!primaryDeclaration || primaryDeclaration.node === node) {
             return;
@@ -3307,7 +3279,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateTypeGuardFunction(node, functionType, isMethod) {
-        var _a;
         const returnType = functionType.shared.declaredReturnType;
         if (!returnType) {
             return;
@@ -3345,7 +3316,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
             // Verify that the typeGuardType is a narrower type than the paramType.
             if (!this._evaluator.assignType(paramType, typeGuardType)) {
-                const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
+                const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
                 if (returnAnnotation) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeIsReturnType().format({
                         type: this._evaluator.printType(paramType),
@@ -3356,11 +3327,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _validateDunderSignatures(node, functionType, isMethod) {
-        var _a;
         const functionName = functionType.shared.name;
         // Is this an '__init__' method? Verify that it returns None.
         if (isMethod && functionName === '__init__') {
-            const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
+            const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
             const declaredReturnType = functionType.shared.declaredReturnType;
             if (returnAnnotation && declaredReturnType) {
                 if (!(0, typeUtils_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
@@ -3378,13 +3348,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _validateFunctionReturn(node, functionType) {
-        var _a;
         // Stub files are allowed not to return an actual value,
         // so skip this if it's a stub file.
         if (this._fileInfo.isStubFile) {
             return;
         }
-        const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
+        const returnAnnotation = node.d.returnAnnotation || node.d.funcAnnotationComment?.d.returnAnnotation;
         if (returnAnnotation) {
             const functionNeverReturns = !this._evaluator.isAfterNodeReachable(node);
             const implicitlyReturnsNone = this._evaluator.isAfterNodeReachable(node.d.suite);
@@ -3426,7 +3395,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (!isEmptySuite) {
                             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnMissing().format({
                                 returnType: this._evaluator.printType(declaredReturnType),
-                            }) + (diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.getString()), returnAnnotation);
+                            }) + diagAddendum?.getString(), returnAnnotation);
                         }
                     }
                 }
@@ -3503,7 +3472,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let newMemberTypeResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, node.d.name, classType, 
         /* diag */ undefined, 4 /* MemberAccessFlags.SkipObjectBaseClass */);
         // If this __new__ comes from a built-in class like Enum, we'll ignore it.
-        if (newMemberTypeResult === null || newMemberTypeResult === void 0 ? void 0 : newMemberTypeResult.classType) {
+        if (newMemberTypeResult?.classType) {
             if ((0, types_1.isClass)(newMemberTypeResult.classType) && types_1.ClassType.isBuiltIn(newMemberTypeResult.classType)) {
                 newMemberTypeResult = undefined;
             }
@@ -3511,13 +3480,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let initMemberTypeResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, node.d.name, types_1.ClassType.cloneAsInstance(classType), 
         /* diag */ undefined, 4 /* MemberAccessFlags.SkipObjectBaseClass */);
         // If this __init__ comes from a built-in class like Enum, we'll ignore it.
-        if (initMemberTypeResult === null || initMemberTypeResult === void 0 ? void 0 : initMemberTypeResult.classType) {
+        if (initMemberTypeResult?.classType) {
             if ((0, types_1.isClass)(initMemberTypeResult.classType) && types_1.ClassType.isBuiltIn(initMemberTypeResult.classType)) {
                 initMemberTypeResult = undefined;
             }
         }
         types_1.ClassType.getSymbolTable(classType).forEach((symbol, name) => {
-            var _a;
             // Determine whether this is an enum member. We ignore the presence
             // of an annotation in this case because the runtime does. From a
             // type checking perspective, if the runtime treats the assignment
@@ -3556,7 +3524,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const declNode = decls[0].node;
             const assignedValueType = symbolType.priv.literalValue.itemType;
             const assignmentNode = ParseTreeUtils.getParentNodeOfType(declNode, 3 /* ParseNodeType.Assignment */);
-            const errorNode = (_a = assignmentNode === null || assignmentNode === void 0 ? void 0 : assignmentNode.d.rightExpr) !== null && _a !== void 0 ? _a : declNode;
+            const errorNode = assignmentNode?.d.rightExpr ?? declNode;
             // Validate the __new__ and __init__ methods if present.
             if (newMemberTypeResult || initMemberTypeResult) {
                 if (!(0, types_1.isAnyOrUnknown)(assignedValueType)) {
@@ -3647,15 +3615,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Verify that the parameter types match.
         let paramIndex = 1;
         initOnlySymbolMap.forEach((symbol, fieldName) => {
-            var _a, _b;
             if (paramIndex >= paramListDetails.params.length) {
                 return;
             }
             const param = paramListDetails.params[paramIndex].param;
-            const paramNode = postInitNode.d.params.find((node) => { var _a; return ((_a = node.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === param.name; });
-            const annotationNode = (_a = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _a !== void 0 ? _a : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
+            const paramNode = postInitNode.d.params.find((node) => node.d.name?.d.value === param.name);
+            const annotationNode = paramNode?.d.annotation ?? paramNode?.d.annotationComment;
             if (types_1.FunctionParam.isTypeDeclared(param) && annotationNode) {
-                const fieldType = (_b = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
+                const fieldType = this._evaluator.getDeclaredTypeOfSymbol(symbol)?.type;
                 const paramType = types_1.FunctionType.getParamType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
@@ -3746,7 +3713,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // If the symbol is assigned (or at least declared) within the
             // class body or within the __init__ method, it can be ignored.
             if (decls.find((decl) => {
-                var _a, _b, _c;
                 const containingClass = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
                 if (!containingClass) {
                     return true;
@@ -3754,11 +3720,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (containingClass.nodeType === 10 /* ParseNodeType.Class */) {
                     // If this is part of an assignment statement, assume it has been
                     // initialized as a class variable.
-                    if (((_a = decl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */) {
+                    if (decl.node.parent?.nodeType === 3 /* ParseNodeType.Assignment */) {
                         return true;
                     }
-                    if (((_b = decl.node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 54 /* ParseNodeType.TypeAnnotation */ &&
-                        ((_c = decl.node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* ParseNodeType.Assignment */) {
+                    if (decl.node.parent?.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                        decl.node.parent.parent?.nodeType === 3 /* ParseNodeType.Assignment */) {
                         return true;
                     }
                     // If this is part of a dataclass, a class handled by a dataclass_transform,
@@ -3802,7 +3768,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // Dataclass fields are typically exempted from this check because
             // they have synthesized __init__ methods that initialize these variables.
-            const dcEntry = dataClassEntries === null || dataClassEntries === void 0 ? void 0 : dataClassEntries.find((entry) => entry.name === name);
+            const dcEntry = dataClassEntries?.find((entry) => entry.name === name);
             if (dcEntry) {
                 if (dcEntry.includeInInit) {
                     return;
@@ -4140,7 +4106,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _validateMultipleInheritanceOverride(overriddenClassAndSymbol, overrideClassAndSymbol, childClassType, memberName, errorNode) {
-        var _a, _b, _c, _d;
         if (!(0, types_1.isClass)(overriddenClassAndSymbol.classType) || !(0, types_1.isClass)(overrideClassAndSymbol.classType)) {
             return;
         }
@@ -4210,7 +4175,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // rule is disabled.
             if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
                 const primaryDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overriddenClassAndSymbol.symbol);
-                let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
+                let isInvariant = primaryDecl?.type === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
                 // If the entry is a member of a frozen dataclass, it is immutable,
                 // so it does not need to be invariant.
                 if (types_1.ClassType.isDataClassFrozen(overriddenClassAndSymbol.classType) &&
@@ -4223,17 +4188,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 let overriddenTDEntry;
                 if (overriddenClassAndSymbol.classType.shared.typedDictEntries) {
                     overriddenTDEntry =
-                        (_b = (_a = overriddenClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _a !== void 0 ? _a : overriddenClassAndSymbol.classType.shared.typedDictEntries.extraItems) !== null && _b !== void 0 ? _b : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overriddenClassAndSymbol.classType);
-                    if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                        overriddenClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName) ??
+                            overriddenClassAndSymbol.classType.shared.typedDictEntries.extraItems ??
+                            (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overriddenClassAndSymbol.classType);
+                    if (overriddenTDEntry?.isReadOnly) {
                         isInvariant = false;
                     }
                 }
                 let overrideTDEntry;
                 if (overrideClassAndSymbol.classType.shared.typedDictEntries) {
                     overrideTDEntry =
-                        (_d = (_c = overrideClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _c !== void 0 ? _c : overrideClassAndSymbol.classType.shared.typedDictEntries.extraItems) !== null && _d !== void 0 ? _d : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overrideClassAndSymbol.classType);
+                        overrideClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName) ??
+                            overrideClassAndSymbol.classType.shared.typedDictEntries.extraItems ??
+                            (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overrideClassAndSymbol.classType);
                 }
-                if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
+                if (!this._evaluator.assignType(overriddenType, childOverrideType ?? overrideType, 
                 /* diag */ undefined, 
                 /* constraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.Invariant */ : 0 /* AssignTypeFlags.Default */)) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
@@ -4283,9 +4252,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateMultipleInheritancePropertyOverride(overriddenClassType, overrideClassType, overriddenSymbolType, overrideSymbolType, overrideSymbol, memberName, errorNode) {
         const propMethodInfo = [
-            ['fget', (c) => { var _a; return (_a = c.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fset', (c) => { var _a; return (_a = c.priv.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fdel', (c) => { var _a; return (_a = c.priv.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fget', (c) => c.priv.fgetInfo?.methodType],
+            ['fset', (c) => c.priv.fsetInfo?.methodType],
+            ['fdel', (c) => c.priv.fdelInfo?.methodType],
         ];
         propMethodInfo.forEach((info) => {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -4367,12 +4336,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             overloads.forEach((overload) => {
-                var _a;
                 const decl = overload.shared.declaration;
                 if (types_1.FunctionType.isAbstractMethod(overload) && decl) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadAbstractImplMismatch().format({
                         name: overload.shared.name,
-                    }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+                    }), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
                 }
             });
             return;
@@ -4384,11 +4352,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // abstract or not abstract.
         const isFirstOverloadAbstract = types_1.FunctionType.isAbstractMethod(overloads[0]);
         overloads.slice(1).forEach((overload, index) => {
-            var _a;
             if (types_1.FunctionType.isAbstractMethod(overload) !== isFirstOverloadAbstract && overload.shared.declaration) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadAbstractMismatch().format({
                     name: overload.shared.name,
-                }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _a !== void 0 ? _a : overload.shared.declaration.node);
+                }), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
             }
         });
     }
@@ -4400,11 +4367,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // implementation is not, report an error.
             if (!types_1.FunctionType.isFinal(implementation)) {
                 overloads.forEach((overload) => {
-                    var _a, _b;
-                    if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                    if (types_1.FunctionType.isFinal(overload) && overload.shared.declaration?.node) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
                             name: overload.shared.name,
-                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
+                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
                     }
                 });
             }
@@ -4412,12 +4378,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (overloads.length > 0 && !types_1.FunctionType.isFinal(overloads[0])) {
             overloads.slice(1).forEach((overload, index) => {
-                var _a, _b;
-                if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                if (types_1.FunctionType.isFinal(overload) && overload.shared.declaration?.node) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
                         name: overload.shared.name,
                         index: index + 2,
-                    }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
+                    }), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
                 }
             });
         }
@@ -4538,7 +4503,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!baseClassAndSymbol) {
                     continue;
                 }
-                firstOverride = firstOverride !== null && firstOverride !== void 0 ? firstOverride : baseClassAndSymbol;
+                firstOverride = firstOverride ?? baseClassAndSymbol;
                 this._validateBaseClassOverride(baseClassAndSymbol, symbol, validateType ? typeOfSymbol : types_1.AnyType.create(), classType, name);
             }
             if (!firstOverride) {
@@ -4571,7 +4536,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
-        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.shared.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
+        if (!overrideFunction?.shared.declaration || types_1.FunctionType.isOverridden(overrideFunction)) {
             return;
         }
         // Constructors are exempt.
@@ -4617,7 +4582,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
-        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.shared.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
+        if (!overrideFunction?.shared.declaration || !types_1.FunctionType.isOverridden(overrideFunction)) {
             return;
         }
         // If the declaration for the override function is not the same as the
@@ -4629,7 +4594,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overriddenMethodNotFound().format({ name: funcNode.d.name.d.value }), funcNode.d.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
@@ -4705,7 +4669,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.shared.name,
-                            }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+                            }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4726,7 +4690,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             name: memberName,
                             className: baseClass.shared.name,
                             type: this._evaluator.printType(overrideType),
-                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
+                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4744,7 +4708,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                         name: memberName,
                         className: baseClass.shared.name,
-                    }), (_c = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _c !== void 0 ? _c : lastDecl.node);
+                    }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                 }
             }
             else {
@@ -4761,7 +4725,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const primaryDecl = decls[0];
                     // Verify that the override type is assignable to (same or narrower than)
                     // the declared type of the base symbol.
-                    let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
+                    let isInvariant = primaryDecl?.type === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
                     // If the entry is a member of a frozen dataclass, it is immutable,
                     // so it does not need to be invariant.
                     if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
@@ -4775,14 +4739,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!overrideSymbol.isIgnoredForProtocolMatch()) {
                         if (baseClass.shared.typedDictEntries) {
                             overriddenTDEntry =
-                                (_e = (_d = baseClass.shared.typedDictEntries.knownItems.get(memberName)) !== null && _d !== void 0 ? _d : baseClass.shared.typedDictEntries.extraItems) !== null && _e !== void 0 ? _e : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
-                            if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                                baseClass.shared.typedDictEntries.knownItems.get(memberName) ??
+                                    baseClass.shared.typedDictEntries.extraItems ??
+                                    (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
+                            if (overriddenTDEntry?.isReadOnly) {
                                 isInvariant = false;
                             }
                         }
                         if (childClassType.shared.typedDictEntries) {
                             overrideTDEntry =
-                                (_g = (_f = childClassType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _f !== void 0 ? _f : childClassType.shared.typedDictEntries.extraItems) !== null && _g !== void 0 ? _g : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
+                                childClassType.shared.typedDictEntries.knownItems.get(memberName) ??
+                                    childClassType.shared.typedDictEntries.extraItems ??
+                                    (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
                         }
                     }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -4799,7 +4767,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
                             name: memberName,
                             className: baseClass.shared.name,
-                        }) + diagAddendum.getString(), (_h = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _h !== void 0 ? _h : lastDecl.node);
+                        }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
@@ -4820,14 +4788,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const message = overrideTDEntry.isRequired
                                 ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
                                 : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (_j = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _j !== void 0 ? _j : lastDecl.node);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         }
                         // Make sure that the derived class isn't marking a previously writable
                         // entry as read-only.
                         if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
                             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
                                 name: memberName,
-                            }), (_k = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _k !== void 0 ? _k : lastDecl.node);
+                            }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         }
                     }
                     // Verify that there is not a Final mismatch.
@@ -4837,7 +4805,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
                             name: memberName,
                             className: baseClass.shared.name,
-                        }), (_l = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _l !== void 0 ? _l : lastDecl.node);
+                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         if (diag) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
                         }
@@ -4869,7 +4837,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClass.shared.name,
-                        }), (_m = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _m !== void 0 ? _m : lastDecl.node);
+                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
@@ -4881,12 +4849,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
-            ['fget', (c) => { var _a; return (_a = c.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fset', (c) => { var _a; return (_a = c.priv.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fdel', (c) => { var _a; return (_a = c.priv.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fget', (c) => c.priv.fgetInfo?.methodType],
+            ['fset', (c) => c.priv.fsetInfo?.methodType],
+            ['fdel', (c) => c.priv.fdelInfo?.methodType],
         ];
         propMethodInfo.forEach((info) => {
-            var _a, _b;
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             const [methodName, methodAccessor] = info;
             const baseClassPropMethod = methodAccessor(baseType);
@@ -4908,7 +4875,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                             name: memberName,
                             className: baseClassType.shared.name,
-                        }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
+                        }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
                         const origDecl = baseClassMethodType.shared.declaration;
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4944,7 +4911,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         return;
                     }
                     const lastSymbolDecl = symbolDecls[symbolDecls.length - 1];
-                    diagLocation = (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastSymbolDecl)) !== null && _b !== void 0 ? _b : lastSymbolDecl.node;
+                    diagLocation = (0, declarationUtils_1.getNameNodeForDeclaration)(lastSymbolDecl) ?? lastSymbolDecl.node;
                 }
                 const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                     name: memberName,
@@ -5104,7 +5071,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Validates that the annotated type of a "self" or "cls" parameter is
     // compatible with the type of the class that contains it.
     _validateClsSelfParamType(node, functionType, classType, isCls) {
-        var _a;
         if (node.d.params.length < 1 || functionType.shared.parameters.length < 1) {
             return;
         }
@@ -5112,7 +5078,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // the type will be inferred.d.typeAnnotation
         const paramInfo = functionType.shared.parameters[0];
         const paramType = types_1.FunctionType.getParamType(functionType, 0);
-        const paramAnnotation = (_a = node.d.params[0].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[0].d.annotationComment;
+        const paramAnnotation = node.d.params[0].d.annotation ?? node.d.params[0].d.annotationComment;
         if (!paramAnnotation || !paramInfo.name) {
             return;
         }
@@ -5121,11 +5087,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // according to the typing spec.
         if (functionType.shared.name === '__init__' && functionType.shared.methodClass) {
             const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramType);
-            if (typeVars.some((typeVar) => {
-                var _a;
-                return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) &&
-                    !types_1.TypeVarType.isSelf(typeVar);
-            })) {
+            if (typeVars.some((typeVar) => typeVar.priv.scopeId === functionType.shared.methodClass?.shared.typeVarScopeId &&
+                !types_1.TypeVarType.isSelf(typeVar))) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
         }
@@ -5177,7 +5140,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether a yield or yield from node is compatible with the
     // return type annotation of the containing function.
     _validateYieldType(node, yieldType, expectedDiagAddendum, sendType) {
-        var _a, _b, _c, _d;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         if (!enclosingFunctionNode || !enclosingFunctionNode.d.returnAnnotation) {
             return;
@@ -5213,7 +5175,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsYield(), node);
             return;
         }
-        const generatorTypeArgs = [yieldType, sendType !== null && sendType !== void 0 ? sendType : types_1.UnknownType.create(), types_1.UnknownType.create()];
+        const generatorTypeArgs = [yieldType, sendType ?? types_1.UnknownType.create(), types_1.UnknownType.create()];
         const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(generatorType, generatorTypeArgs));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
@@ -5221,7 +5183,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
-                ((_a = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getString()) !== null && _a !== void 0 ? _a : diagAddendum.getString()), (_b = node.d.expr) !== null && _b !== void 0 ? _b : node, (_d = (_c = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.expr) !== null && _d !== void 0 ? _d : node);
+                (expectedDiagAddendum?.getString() ?? diagAddendum.getString()), node.d.expr ?? node, expectedDiagAddendum?.getEffectiveTextRange() ?? node.d.expr ?? node);
         }
     }
     // Determines whether any of the except statements are unreachable because
@@ -5230,7 +5192,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let sawUnknownExceptionType = false;
         const exceptionTypesSoFar = [];
         node.d.exceptClauses.forEach((except) => {
-            var _a, _b;
             if (sawUnknownExceptionType || except.d.isExceptGroup || !except.d.typeExpr) {
                 return;
             }
@@ -5249,10 +5210,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 typesOfThisExcept.push(exceptionType);
             }
             else if ((0, types_1.isClassInstance)(exceptionType)) {
-                const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
+                const iterableType = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
                 /* isAsync */ false, 
                 /* errorNode */ except.d.typeExpr, 
-                /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                /* emitNotIterableError */ false)?.type ?? types_1.UnknownType.create();
                 (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         sawUnknownExceptionType = true;