@zzzen/pyright-internal 1.2.0-dev.20231119 → 1.2.0-dev.20231203

package/dist/analyzer/checker.js

@@ -14,7 +14,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -216,14 +220,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Report any unknown or missing parameter types.
             node.parameters.forEach((param, index) => {
                 if (param.name) {
-                    if (param.category === 0 /* Simple */ && index >= paramDetails.positionOnlyParamCount) {
+                    if (param.category === 0 /* ParameterCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
                         keywordNames.add(param.name.value);
                     }
                     // Determine whether this is a P.args parameter.
-                    if (param.category === 1 /* ArgsList */) {
+                    if (param.category === 1 /* ParameterCategory.ArgsList */) {
                         const annotationExpr = param.typeAnnotation || param.typeAnnotationComment;
                         if (annotationExpr &&
-                            annotationExpr.nodeType === 35 /* MemberAccess */ &&
+                            annotationExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                             annotationExpr.memberName.value === 'args') {
                             const baseType = this._evaluator.getType(annotationExpr.leftExpression);
                             if (baseType && (0, types_1.isTypeVar)(baseType) && baseType.details.isParamSpec) {
@@ -231,11 +235,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }
                         }
                     }
-                    else if (param.category === 2 /* KwargsDict */) {
+                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                         sawParamSpecArgs = false;
                     }
                 }
-                if (param.name && param.category === 0 /* Simple */ && sawParamSpecArgs) {
+                if (param.name && param.category === 0 /* ParameterCategory.Simple */ && sawParamSpecArgs) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedParamAfterParamSpecArgs().format({ name: param.name.value }), param.name);
                 }
                 // Allow unknown and missing param types if the param is named '_'.
@@ -297,7 +301,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Check for invalid use of ParamSpec P.args and P.kwargs.
             const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
                 if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
-                    if (param.category !== 0 /* Simple */ && param.name && param.type.paramSpecAccess) {
+                    if (param.category !== 0 /* ParameterCategory.Simple */ && param.name && param.type.paramSpecAccess) {
                         return true;
                     }
                 }
@@ -335,7 +339,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const exemptMethods = ['__init__', '__new__'];
                     if (containingClassNode &&
                         (0, types_1.isTypeVar)(paramType) &&
-                        paramType.details.declaredVariance === 3 /* Covariant */ &&
+                        paramType.details.declaredVariance === 3 /* Variance.Covariant */ &&
                         !paramType.details.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.details.name)) {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramTypeCovariant(), annotationNode);
@@ -381,13 +385,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
             this._validateGeneratorReturnType(node, functionTypeResult.functionType);
+            this._reportDeprecatedClassProperty(node, functionTypeResult);
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
         // This signifies an incomplete stub file that obscures type errors.
         if (this._fileInfo.isStubFile && node.name.value === '__getattr__') {
             const scope = (0, scopeUtils_1.getScopeForNode)(node);
-            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* Module */) {
+            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* ScopeType.Module */) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompleteStub, diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.Localizer.Diagnostic.stubUsesGetAttr(), node.name);
             }
         }
@@ -408,6 +413,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
+            this._validateOverloadAttributeConsistency(node, functionTypeResult.decoratedType);
         }
         return false;
     }
@@ -449,8 +455,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         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 /* StatementList */) {
-                const isRevealTypeCall = node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'reveal_type';
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */) {
+                const isRevealTypeCall = node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === 'reveal_type';
                 const returnType = this._evaluator.getType(node);
                 if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
@@ -467,8 +473,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitAwait(node) {
         var _a;
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none') {
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */ &&
-                node.expression.nodeType === 9 /* Call */) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ &&
+                node.expression.nodeType === 9 /* ParseNodeType.Call */) {
                 const returnType = this._evaluator.getType(node);
                 if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
@@ -527,7 +533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitReturn(node) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         let returnTypeResult;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         const declaredReturnType = enclosingFunctionNode
@@ -545,7 +551,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // at runtime in this case.
         if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.isAsync) && node.returnExpression) {
             const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
-            if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* Function */ && functionDecl.isGenerator) {
+            if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
                 this._evaluator.addError(localize_1.Localizer.Diagnostic.returnInAsyncGenerator(), node.returnExpression);
             }
         }
@@ -558,7 +564,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnTypeResult.type, diagAddendum, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
+                    /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
                     else {
@@ -581,7 +587,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
                                 if (this._evaluator.assignType(adjustedReturnType, returnTypeResult.type, diagAddendum, 
                                 /* destTypeVarContext */ undefined, 
-                                /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
+                                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -596,17 +602,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnTypeResult.type),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node, (_b = returnTypeResult.expectedTypeDiagAddendum) === null || _b === void 0 ? void 0 : _b.getEffectiveTextRange());
+                        }) + diagAddendum.getString(), (_b = node.returnExpression) !== null && _b !== void 0 ? _b : node, (_c = returnTypeResult.expectedTypeDiagAddendum) === null || _c === void 0 ? void 0 : _c.getEffectiveTextRange());
                     }
                 }
             }
             if ((0, types_1.isUnknown)(returnTypeResult.type)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.returnExpression);
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnTypeResult.type)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnTypeResult.type, { expandTypeAlias: true }),
-                }), node.returnExpression);
+                }), (_e = node.returnExpression) !== null && _e !== void 0 ? _e : node);
             }
         }
         return true;
@@ -719,14 +725,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         // If this isn't a class or global scope, explicit type aliases are not allowed.
-        if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
+        if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
             const annotationType = this._evaluator.getTypeOfAnnotation(node.leftExpression.typeAnnotation);
             if ((0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias')) {
                 const scope = (0, scopeUtils_1.getScopeForNode)(node);
                 if (scope) {
-                    if (scope.type !== 2 /* Class */ &&
-                        scope.type !== 3 /* Module */ &&
-                        scope.type !== 4 /* Builtin */) {
+                    if (scope.type !== 2 /* ScopeType.Class */ &&
+                        scope.type !== 3 /* ScopeType.Module */ &&
+                        scope.type !== 4 /* ScopeType.Builtin */) {
                         this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
                     }
                 }
@@ -756,7 +762,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const tupleLength = subtype.tupleTypeArguments.length;
                     if (node.items.length === 1 &&
                         !node.trailingComma &&
-                        node.items[0].argumentCategory === 0 /* Simple */ &&
+                        node.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
                         !node.items[0].name) {
                         const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
                         if (subscriptType &&
@@ -779,23 +785,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitBinaryOperation(node) {
-        if (node.operator === 36 /* And */ || node.operator === 37 /* Or */) {
+        if (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */) {
             this._validateConditionalIsBool(node.leftExpression);
             this._validateConditionalIsBool(node.rightExpression);
         }
-        if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
+        if (node.operator === 12 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateComparisonTypes(node);
             }
         }
-        else if (node.operator === 39 /* Is */ || node.operator === 40 /* IsNot */) {
+        else if (node.operator === 39 /* OperatorType.Is */ || node.operator === 40 /* OperatorType.IsNot */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateComparisonTypesForIsOperator(node);
             }
         }
-        else if (node.operator === 41 /* In */ || node.operator === 42 /* NotIn */) {
+        else if (node.operator === 41 /* OperatorType.In */ || node.operator === 42 /* OperatorType.NotIn */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateContainmentTypes(node);
@@ -817,7 +823,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitUnaryOperation(node) {
-        if (node.operator === 38 /* Not */) {
+        if (node.operator === 38 /* OperatorType.Not */) {
             this._validateConditionalIsBool(node.expression);
         }
         this._evaluator.getType(node);
@@ -837,22 +843,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_12) {
             let curNode = node;
             while (curNode) {
-                if (curNode.nodeType === 27 /* FormatString */) {
+                if (curNode.nodeType === 27 /* ParseNodeType.FormatString */) {
                     fStringContainers.push(curNode);
                 }
                 curNode = curNode.parent;
             }
         }
         for (const stringNode of node.strings) {
-            const stringTokens = stringNode.nodeType === 49 /* String */ ? [stringNode.token] : stringNode.middleTokens;
+            const stringTokens = stringNode.nodeType === 49 /* ParseNodeType.String */ ? [stringNode.token] : stringNode.middleTokens;
             stringTokens.forEach((token) => {
                 const unescapedResult = (0, stringTokenUtils_1.getUnescapedString)(token);
                 let start = token.start;
-                if (token.type === 5 /* String */) {
+                if (token.type === 5 /* TokenType.String */) {
                     start += token.prefixLength + token.quoteMarkLength;
                 }
                 unescapedResult.unescapeErrors.forEach((error) => {
-                    if (error.errorType === 0 /* InvalidEscapeSequence */) {
+                    if (error.errorType === 0 /* UnescapeErrorType.InvalidEscapeSequence */) {
                         this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.Localizer.Diagnostic.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
                     }
                 });
@@ -867,7 +873,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Prior to Python 3.12, it was not allowed to nest strings that
             // used the same quote scheme within an f-string.
             if (fStringContainers.length > 0) {
-                const quoteTypeMask = 1 /* SingleQuote */ | 2 /* DoubleQuote */ | 4 /* Triplicate */;
+                const quoteTypeMask = 1 /* StringTokenFlags.SingleQuote */ | 2 /* StringTokenFlags.DoubleQuote */ | 4 /* StringTokenFlags.Triplicate */;
                 if (fStringContainers.some((fStringContainer) => (fStringContainer.token.flags & quoteTypeMask) === (stringNode.token.flags & quoteTypeMask))) {
                     this._evaluator.addError(localize_1.Localizer.Diagnostic.formatStringNestedQuote(), stringNode);
                 }
@@ -966,7 +972,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
             if (importInfo &&
                 importInfo.isImportFound &&
-                importInfo.importType !== 2 /* Local */ &&
+                importInfo.importType !== 2 /* ImportType.Local */ &&
                 !this._fileInfo.isStubFile) {
                 this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.Localizer.Diagnostic.wildcardLibraryImport(), node.wildcardToken || node);
             }
@@ -999,7 +1005,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             break;
         }
         let isImportFromTyping = false;
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ImportFrom */) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */) {
             if (node.parent.module.leadingDots === 0 && node.parent.module.nameParts.length === 1) {
                 if (node.parent.module.nameParts[0].value === 'typing') {
                     isImportFromTyping = true;
@@ -1026,6 +1032,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitTypeParameter(node) {
         return false;
     }
+    visitTypeAlias(node) {
+        const scope = (0, scopeUtils_1.getScopeForNode)(node);
+        if (scope) {
+            if (scope.type !== 2 /* ScopeType.Class */ && scope.type !== 3 /* ScopeType.Module */ && scope.type !== 4 /* ScopeType.Builtin */) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasStatementBadScope(), node.name);
+            }
+        }
+        return true;
+    }
     visitTypeAnnotation(node) {
         this._evaluator.getType(node.typeAnnotation);
         return true;
@@ -1074,7 +1089,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _addMissingModuleSourceDiagnosticIfNeeded(importResult, node) {
         if (importResult.isNativeLib ||
             !importResult.isStubFile ||
-            importResult.importType === 0 /* BuiltIn */ ||
+            importResult.importType === 0 /* ImportType.BuiltIn */ ||
             !importResult.nonStubImportResult ||
             importResult.nonStubImportResult.isImportFound) {
             return;
@@ -1124,15 +1139,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportUnnecessaryConditionExpression(expression) {
-        if (expression.nodeType === 7 /* BinaryOperation */) {
-            if (expression.operator === 36 /* And */ || expression.operator === 37 /* Or */) {
+        if (expression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
+            if (expression.operator === 36 /* OperatorType.And */ || expression.operator === 37 /* OperatorType.Or */) {
                 this._reportUnnecessaryConditionExpression(expression.leftExpression);
                 this._reportUnnecessaryConditionExpression(expression.rightExpression);
             }
             return;
         }
-        else if (expression.nodeType === 55 /* UnaryOperation */) {
-            if (expression.operator === 38 /* Not */) {
+        else if (expression.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
+            if (expression.operator === 38 /* OperatorType.Not */) {
                 this._reportUnnecessaryConditionExpression(expression.expression);
             }
             return;
@@ -1162,30 +1177,30 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const simpleExpressionTypes = [
-            55 /* UnaryOperation */,
-            7 /* BinaryOperation */,
-            40 /* Number */,
-            11 /* Constant */,
-            38 /* Name */,
-            52 /* Tuple */,
+            55 /* ParseNodeType.UnaryOperation */,
+            7 /* ParseNodeType.BinaryOperation */,
+            40 /* ParseNodeType.Number */,
+            11 /* ParseNodeType.Constant */,
+            38 /* ParseNodeType.Name */,
+            52 /* ParseNodeType.Tuple */,
         ];
         let reportAsUnused = false;
         if (simpleExpressionTypes.some((nodeType) => nodeType === node.nodeType)) {
             reportAsUnused = true;
         }
-        else if (node.nodeType === 31 /* List */ ||
-            node.nodeType === 45 /* Set */ ||
-            node.nodeType === 15 /* Dictionary */) {
+        else if (node.nodeType === 31 /* ParseNodeType.List */ ||
+            node.nodeType === 45 /* ParseNodeType.Set */ ||
+            node.nodeType === 15 /* ParseNodeType.Dictionary */) {
             // Exclude comprehensions.
-            if (!node.entries.some((entry) => entry.nodeType === 32 /* ListComprehension */)) {
+            if (!node.entries.some((entry) => entry.nodeType === 32 /* ParseNodeType.ListComprehension */)) {
                 reportAsUnused = true;
             }
         }
         if (reportAsUnused &&
             this._fileInfo.ipythonMode === sourceFile_1.IPythonMode.CellDocs &&
-            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */ &&
+            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ &&
             node.parent.statements[node.parent.statements.length - 1] === node &&
-            ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 36 /* Module */ &&
+            ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 36 /* ParseNodeType.Module */ &&
             node.parent.parent.statements[node.parent.parent.statements.length - 1] === node.parent) {
             // Exclude an expression at the end of a notebook cell, as that is treated as
             // the cell's value.
@@ -1262,7 +1277,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const narrowedType = (0, typeGuards_1.narrowTypeForContainerElementType)(this._evaluator, leftType, this._evaluator.makeTopLevelTypeVarsConcrete(elementType));
         if ((0, types_1.isNever)(narrowedType)) {
             const getMessage = () => {
-                return node.operator === 41 /* In */
+                return node.operator === 41 /* OperatorType.In */
                     ? localize_1.Localizer.Diagnostic.containmentAlwaysFalse()
                     : localize_1.Localizer.Diagnostic.containmentAlwaysTrue();
             };
@@ -1291,7 +1306,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         const getMessage = () => {
-            return node.operator === 39 /* Is */
+            return node.operator === 39 /* OperatorType.Is */
                 ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
                 : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
         };
@@ -1307,7 +1322,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateComparisonTypes(node) {
         let rightExpression = node.rightExpression;
         // Check for chained comparisons.
-        if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
+        if (rightExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
             !rightExpression.parenthesized &&
             ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
             // Use the left side of the right expression for comparison purposes.
@@ -1322,7 +1337,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const getMessage = () => {
-            return node.operator === 12 /* Equals */
+            return node.operator === 12 /* OperatorType.Equals */
                 ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
                 : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
         };
@@ -1408,7 +1423,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Does the class have an operator overload for eq?
             const metaclass = leftType.details.effectiveMetaclass;
             if (metaclass && (0, types_1.isClass)(metaclass)) {
-                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* SkipObjectBaseClass */)) {
+                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
                     return true;
                 }
             }
@@ -1433,7 +1448,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             // Does the class have an operator overload for eq?
-            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* SkipObjectBaseClass */);
+            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
             if (eqMethod) {
                 // If this is a synthesized method for a dataclass, we can assume
                 // that other dataclass types will not be comparable.
@@ -1509,7 +1524,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let constructorClass;
         if (types_1.FunctionType.isInstanceMethod(type) && node.name.value === '__init__') {
             const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(node);
-            if (containingClassNode && containingClassNode.nodeType === 10 /* Class */) {
+            if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = this._evaluator.getTypeOfClass(containingClassNode);
                 if (classType && (0, types_1.isClass)(classType.classType)) {
                     constructorClass = classType.classType;
@@ -1523,14 +1538,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.details.isSynthesizedSelf) {
                 // Does this name refer to a TypeVar that is scoped to this function?
                 if (nameType.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
-                    // We exempt constrained TypeVars, bound TypeVars that are type arguments of
+                    // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
                     let isExempt = nameType.details.constraints.length > 0 ||
                         !!nameType.details.defaultType ||
-                        (exemptBoundTypeVar &&
-                            nameType.details.boundType !== undefined &&
-                            subscriptIndex !== undefined) ||
+                        (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
                     if (!isExempt && baseExpression && subscriptIndex !== undefined) {
                         // Is this a type argument for a generic type alias? If so,
@@ -1544,10 +1557,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const existingEntry = localTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 18 /* Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 18 /* ParseNodeType.Ellipsis */;
                     if (!existingEntry) {
                         localTypeVarUsage.set(nameType.details.name, {
                             nodes: [nameNode],
+                            typeVar: nameType,
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
                             returnTypeUsageCount: curParamNode === undefined ? 1 : 0,
@@ -1575,10 +1589,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // this constructor method?
                 if (constructorClass && nameType.scopeId === constructorClass.details.typeVarScopeId) {
                     const existingEntry = classTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 18 /* Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 18 /* ParseNodeType.Ellipsis */;
                     const isExempt = !!nameType.details.defaultType;
                     if (!existingEntry) {
                         classTypeVarUsage.set(nameType.details.name, {
+                            typeVar: nameType,
                             nodes: [nameNode],
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
@@ -1622,9 +1637,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             var _a;
             // Report error for local type variable that appears only once.
             if (usage.nodes.length === 1 && !usage.isExempt) {
+                let altTypeText;
+                if (usage.typeVar.details.isVariadic) {
+                    altTypeText = '"tuple[object, ...]"';
+                }
+                else if (usage.typeVar.details.boundType) {
+                    altTypeText = `"${this._evaluator.printType((0, typeUtils_1.convertToInstance)(usage.typeVar.details.boundType))}"`;
+                }
+                else {
+                    altTypeText = '"object"';
+                }
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnnecessarySuggestion().format({
+                    type: altTypeText,
+                }));
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarUsedOnlyOnce().format({
                     name: usage.nodes[0].value,
-                }), usage.nodes[0]);
+                }) + diag.getString(), usage.nodes[0]);
             }
             // Report error for local type variable that appears in return type
             // (but not as a top-level TypeVar within a union) and appears only
@@ -1673,6 +1702,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
+    // Validates that overloads use @staticmethod and @classmethod consistently.
+    _validateOverloadAttributeConsistency(node, functionType) {
+        var _a, _b, _c, _d, _e, _f;
+        let staticMethodCount = 0;
+        let classMethodCount = 0;
+        functionType.overloads.forEach((overload) => {
+            if (types_1.FunctionType.isStaticMethod(overload)) {
+                staticMethodCount++;
+            }
+            if (types_1.FunctionType.isClassMethod(overload)) {
+                classMethodCount++;
+            }
+        });
+        if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadStaticMethodInconsistent().format({
+                name: node.name.value,
+            }), (_c = (_b = (_a = functionType.overloads[0]) === null || _a === void 0 ? void 0 : _a.details.declaration) === null || _b === void 0 ? void 0 : _b.node.name) !== null && _c !== void 0 ? _c : node.name);
+        }
+        if (classMethodCount > 0 && classMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadClassMethodInconsistent().format({
+                name: node.name.value,
+            }), (_f = (_e = (_d = functionType.overloads[0]) === null || _d === void 0 ? void 0 : _d.details.declaration) === null || _e === void 0 ? void 0 : _e.node.name) !== null && _f !== void 0 ? _f : node.name);
+        }
+    }
+    // Validates that overloads do not overlap with inconsistent return results.
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
@@ -1694,7 +1748,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
                     /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */ | 512 /* IgnoreTypeVarScope */)) {
+                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 512 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overloadReturnTypeMismatch().format({
                         name: node.name.value,
@@ -1715,7 +1769,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return undefined;
         }
         for (const decl of decls) {
-            if (decl.type === 5 /* Function */) {
+            if (decl.type === 5 /* DeclarationType.Function */) {
                 const functionType = this._evaluator.getTypeOfFunction(decl.node);
                 if ((functionType === null || functionType === void 0 ? void 0 : functionType.functionType) === overloadType) {
                     return decl.node;
@@ -1735,22 +1789,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return this._evaluator.assignType(functionType, prevOverload, 
         /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
-        /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */ | 16 /* OverloadOverlapCheck */);
+        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */);
     }
     _isLegalOverloadImplementation(overload, implementation, diag) {
         var _a;
         const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
         const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 32 /* SkipFunctionReturnTypeCheck */ |
-            2 /* ReverseTypeVarMatching */ |
-            256 /* SkipSelfClsTypeCheck */);
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+            2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
+            256 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
         const overloadReturnType = (_a = overload.details.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
         const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.details.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
-            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* SkipSolveTypeVars */)) {
+            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
             returnDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionReturnTypeMismatch().format({
                 sourceType: this._evaluator.printType(overloadReturnType),
                 destType: this._evaluator.printType(implementationReturnType),
@@ -1786,72 +1840,72 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateStubStatement(statement) {
         switch (statement.nodeType) {
-            case 19 /* If */:
-            case 28 /* Function */:
-            case 10 /* Class */:
-            case 0 /* Error */: {
+            case 19 /* ParseNodeType.If */:
+            case 28 /* ParseNodeType.Function */:
+            case 10 /* ParseNodeType.Class */:
+            case 0 /* ParseNodeType.Error */: {
                 // These are allowed in a stub file.
                 break;
             }
-            case 57 /* While */:
-            case 26 /* For */:
-            case 53 /* Try */:
-            case 58 /* With */: {
+            case 57 /* ParseNodeType.While */:
+            case 26 /* ParseNodeType.For */:
+            case 53 /* ParseNodeType.Try */:
+            case 58 /* ParseNodeType.With */: {
                 // These are not allowed.
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.invalidStubStatement(), statement);
                 break;
             }
-            case 47 /* StatementList */: {
+            case 47 /* ParseNodeType.StatementList */: {
                 for (const substatement of statement.statements) {
                     let isValid = true;
                     switch (substatement.nodeType) {
-                        case 2 /* Assert */:
-                        case 4 /* AssignmentExpression */:
-                        case 6 /* Await */:
-                        case 7 /* BinaryOperation */:
-                        case 11 /* Constant */:
-                        case 14 /* Del */:
-                        case 15 /* Dictionary */:
-                        case 24 /* Index */:
-                        case 26 /* For */:
-                        case 27 /* FormatString */:
-                        case 29 /* Global */:
-                        case 30 /* Lambda */:
-                        case 31 /* List */:
-                        case 35 /* MemberAccess */:
-                        case 38 /* Name */:
-                        case 39 /* Nonlocal */:
-                        case 40 /* Number */:
-                        case 43 /* Raise */:
-                        case 44 /* Return */:
-                        case 45 /* Set */:
-                        case 46 /* Slice */:
-                        case 51 /* Ternary */:
-                        case 52 /* Tuple */:
-                        case 53 /* Try */:
-                        case 55 /* UnaryOperation */:
-                        case 56 /* Unpack */:
-                        case 57 /* While */:
-                        case 58 /* With */:
-                        case 59 /* WithItem */:
-                        case 60 /* Yield */:
-                        case 61 /* YieldFrom */: {
+                        case 2 /* ParseNodeType.Assert */:
+                        case 4 /* ParseNodeType.AssignmentExpression */:
+                        case 6 /* ParseNodeType.Await */:
+                        case 7 /* ParseNodeType.BinaryOperation */:
+                        case 11 /* ParseNodeType.Constant */:
+                        case 14 /* ParseNodeType.Del */:
+                        case 15 /* ParseNodeType.Dictionary */:
+                        case 24 /* ParseNodeType.Index */:
+                        case 26 /* ParseNodeType.For */:
+                        case 27 /* ParseNodeType.FormatString */:
+                        case 29 /* ParseNodeType.Global */:
+                        case 30 /* ParseNodeType.Lambda */:
+                        case 31 /* ParseNodeType.List */:
+                        case 35 /* ParseNodeType.MemberAccess */:
+                        case 38 /* ParseNodeType.Name */:
+                        case 39 /* ParseNodeType.Nonlocal */:
+                        case 40 /* ParseNodeType.Number */:
+                        case 43 /* ParseNodeType.Raise */:
+                        case 44 /* ParseNodeType.Return */:
+                        case 45 /* ParseNodeType.Set */:
+                        case 46 /* ParseNodeType.Slice */:
+                        case 51 /* ParseNodeType.Ternary */:
+                        case 52 /* ParseNodeType.Tuple */:
+                        case 53 /* ParseNodeType.Try */:
+                        case 55 /* ParseNodeType.UnaryOperation */:
+                        case 56 /* ParseNodeType.Unpack */:
+                        case 57 /* ParseNodeType.While */:
+                        case 58 /* ParseNodeType.With */:
+                        case 59 /* ParseNodeType.WithItem */:
+                        case 60 /* ParseNodeType.Yield */:
+                        case 61 /* ParseNodeType.YieldFrom */: {
                             isValid = false;
                             break;
                         }
-                        case 5 /* AugmentedAssignment */: {
+                        case 5 /* ParseNodeType.AugmentedAssignment */: {
                             // Exempt __all__ manipulations.
                             isValid =
-                                substatement.operator === 1 /* AddEqual */ &&
-                                    substatement.leftExpression.nodeType === 38 /* Name */ &&
+                                substatement.operator === 1 /* OperatorType.AddEqual */ &&
+                                    substatement.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                                     substatement.leftExpression.value === '__all__';
                             break;
                         }
-                        case 9 /* Call */: {
+                        case 9 /* ParseNodeType.Call */: {
                             // Exempt __all__ manipulations.
                             isValid =
-                                substatement.leftExpression.nodeType === 35 /* MemberAccess */ &&
-                                    substatement.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+                                substatement.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                                    substatement.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                                     substatement.leftExpression.leftExpression.value === '__all__';
                             break;
                         }
@@ -1966,7 +2020,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const typedDecls = symbol.getTypedDeclarations();
         if (typedDecls.length >= 1) {
             const primaryDecl = typedDecls[0];
-            if (primaryDecl.type === 5 /* Function */) {
+            if (primaryDecl.type === 5 /* DeclarationType.Function */) {
                 const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
                 const overloadedFunctions = (0, types_1.isOverloadedFunction)(type)
                     ? types_1.OverloadedFunctionType.getOverloads(type)
@@ -1990,7 +2044,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!implementationFunction) {
                         let exemptMissingImplementation = false;
                         const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
-                        if (containingClassNode && containingClassNode.nodeType === 10 /* Class */) {
+                        if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                             const classType = this._evaluator.getTypeOfClass(containingClassNode);
                             if (classType) {
                                 if (types_1.ClassType.isProtocolClass(classType.classType)) {
@@ -2048,13 +2102,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 sawFinal = true;
             }
-            if (decl.type === 1 /* Variable */ && decl.inferredTypeSource) {
+            if (decl.type === 1 /* DeclarationType.Variable */ && decl.inferredTypeSource) {
                 if (sawAssignment) {
                     // We check for assignment of Final instance and class variables
                     // the type evaluator because we need to take into account whether
                     // the assignment is within an `__init__` method, so ignore class
                     // scopes here.
-                    if (scopeType !== 2 /* Class */) {
+                    if (scopeType !== 2 /* ScopeType.Class */) {
                         this._evaluator.addError(localize_1.Localizer.Diagnostic.finalReassigned().format({ name }), decl.node);
                     }
                 }
@@ -2063,7 +2117,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
         // If it's not a stub file, an assignment must be provided.
         if (!sawAssignment && !this._fileInfo.isStubFile) {
-            const firstDecl = decls.find((decl) => decl.type === 1 /* Variable */ && decl.isFinal);
+            const firstDecl = decls.find((decl) => decl.type === 1 /* DeclarationType.Variable */ && decl.isFinal);
             if (firstDecl) {
                 // Is this an instance variable declared within a dataclass? If so, it
                 // is implicitly initialized by the synthesized `__init__` method and
@@ -2122,10 +2176,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let otherDecls = symbol.getDeclarations().filter((decl) => decl !== primaryDecl);
         // If it's a function, we can skip any other declarations
         // that are overloads or property setters/deleters.
-        if (primaryDecl.type === 5 /* Function */) {
+        if (primaryDecl.type === 5 /* DeclarationType.Function */) {
             const primaryDeclTypeInfo = this._evaluator.getTypeOfFunction(primaryDecl.node);
             otherDecls = otherDecls.filter((decl) => {
-                if (decl.type !== 5 /* Function */) {
+                if (decl.type !== 5 /* DeclarationType.Function */) {
                     return true;
                 }
                 const funcTypeInfo = this._evaluator.getTypeOfFunction(decl.node);
@@ -2153,7 +2207,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let primaryDeclInfo;
-        if (primaryDecl.type === 5 /* Function */) {
+        if (primaryDecl.type === 5 /* DeclarationType.Function */) {
             if (primaryDecl.isMethod) {
                 primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeMethodDeclaration();
             }
@@ -2161,16 +2215,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeFunctionDeclaration();
             }
         }
-        else if (primaryDecl.type === 6 /* Class */) {
+        else if (primaryDecl.type === 6 /* DeclarationType.Class */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeClassDeclaration();
         }
-        else if (primaryDecl.type === 2 /* Parameter */) {
+        else if (primaryDecl.type === 2 /* DeclarationType.Parameter */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeParameterDeclaration();
         }
-        else if (primaryDecl.type === 1 /* Variable */) {
+        else if (primaryDecl.type === 1 /* DeclarationType.Variable */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeVariableDeclaration();
         }
-        else if (primaryDecl.type === 4 /* TypeAlias */) {
+        else if (primaryDecl.type === 4 /* DeclarationType.TypeAlias */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeTypeAliasDeclaration();
         }
         else {
@@ -2179,16 +2233,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const addPrimaryDeclInfo = (diag) => {
             if (diag) {
                 let primaryDeclNode;
-                if (primaryDecl.type === 5 /* Function */ || primaryDecl.type === 6 /* Class */) {
+                if (primaryDecl.type === 5 /* DeclarationType.Function */ || primaryDecl.type === 6 /* DeclarationType.Class */) {
                     primaryDeclNode = primaryDecl.node.name;
                 }
-                else if (primaryDecl.type === 1 /* Variable */) {
-                    if (primaryDecl.node.nodeType === 38 /* Name */) {
+                else if (primaryDecl.type === 1 /* DeclarationType.Variable */) {
+                    if (primaryDecl.node.nodeType === 38 /* ParseNodeType.Name */) {
                         primaryDeclNode = primaryDecl.node;
                     }
                 }
-                else if (primaryDecl.type === 2 /* Parameter */ ||
-                    primaryDecl.type === 3 /* TypeParameter */) {
+                else if (primaryDecl.type === 2 /* DeclarationType.Parameter */ ||
+                    primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                     if (primaryDecl.node.name) {
                         primaryDeclNode = primaryDecl.node.name;
                     }
@@ -2199,9 +2253,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         };
         for (const otherDecl of otherDecls) {
-            if (otherDecl.type === 6 /* Class */) {
+            if (otherDecl.type === 6 /* DeclarationType.Class */) {
                 let duplicateIsOk = false;
-                if (primaryDecl.type === 3 /* TypeParameter */) {
+                if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                     // The error will be reported elsewhere if a type parameter is
                     // involved, so don't report it here.
                     duplicateIsOk = true;
@@ -2211,7 +2265,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     addPrimaryDeclInfo(diag);
                 }
             }
-            else if (otherDecl.type === 5 /* Function */) {
+            else if (otherDecl.type === 5 /* DeclarationType.Function */) {
                 const primaryType = (_a = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _a === void 0 ? void 0 : _a.type;
                 let duplicateIsOk = false;
                 // If the return type has not yet been inferred, do so now.
@@ -2234,7 +2288,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                     duplicateIsOk = true;
                 }
-                if (primaryDecl.type === 3 /* TypeParameter */) {
+                if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                     // The error will be reported elsewhere if a type parameter is
                     // involved, so don't report it here.
                     duplicateIsOk = true;
@@ -2246,10 +2300,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     addPrimaryDeclInfo(diag);
                 }
             }
-            else if (otherDecl.type === 2 /* Parameter */) {
+            else if (otherDecl.type === 2 /* DeclarationType.Parameter */) {
                 if (otherDecl.node.name) {
                     let duplicateIsOk = false;
-                    if (primaryDecl.type === 3 /* TypeParameter */) {
+                    if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                         // The error will be reported elsewhere if a type parameter is
                         // involved, so don't report it here.
                         duplicateIsOk = true;
@@ -2261,17 +2315,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            else if (otherDecl.type === 1 /* Variable */) {
+            else if (otherDecl.type === 1 /* DeclarationType.Variable */) {
                 const primaryType = (_c = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _c === void 0 ? void 0 : _c.type;
                 if (otherDecl.typeAnnotationNode) {
-                    if (otherDecl.node.nodeType === 38 /* Name */) {
+                    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;
                         if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                             duplicateIsOk = true;
                         }
-                        if (primaryDecl.type === 3 /* TypeParameter */) {
+                        if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                             // The error will be reported elsewhere if a type parameter is
                             // involved, so don't report it here.
                             duplicateIsOk = true;
@@ -2283,7 +2337,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            else if (otherDecl.type === 4 /* TypeAlias */) {
+            else if (otherDecl.type === 4 /* DeclarationType.TypeAlias */) {
                 const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
                 addPrimaryDeclInfo(diag);
             }
@@ -2319,10 +2373,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let message;
         let rule;
         switch (decl.type) {
-            case 8 /* Alias */:
+            case 8 /* DeclarationType.Alias */:
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
-                if (decl.node.nodeType === 21 /* ImportAs */) {
+                if (decl.node.nodeType === 21 /* ParseNodeType.ImportAs */) {
                     if (decl.node.alias) {
                         // For statements of the form "import x as x", don't mark "x" as unaccessed
                         // because it's assumed to be re-exported.
@@ -2338,13 +2392,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const multipartName = nameParts.map((np) => np.value).join('.');
                             let textRange = { start: nameParts[0].start, length: nameParts[0].length };
                             textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
-                            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* unusedImport */ });
+                            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* Commands.unusedImport */ });
                             this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportUnusedImport, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: multipartName }), textRange);
                             return;
                         }
                     }
                 }
-                else if (decl.node.nodeType === 23 /* ImportFromAs */) {
+                else if (decl.node.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
                     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.
@@ -2360,9 +2414,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     message = localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: nameNode.value });
                 }
                 break;
-            case 4 /* TypeAlias */:
-            case 1 /* Variable */:
-            case 2 /* Parameter */:
+            case 4 /* DeclarationType.TypeAlias */:
+            case 1 /* DeclarationType.Variable */:
+            case 2 /* DeclarationType.Parameter */:
                 if (!isPrivate) {
                     return;
                 }
@@ -2372,7 +2426,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     return;
                 }
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedVariable;
-                if (decl.node.nodeType === 38 /* Name */) {
+                if (decl.node.nodeType === 38 /* ParseNodeType.Name */) {
                     nameNode = decl.node;
                     // Don't emit a diagnostic if the name starts with an underscore.
                     // This indicates that the variable is unused.
@@ -2380,7 +2434,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diagnosticLevel = 'none';
                     }
                 }
-                else if (decl.node.nodeType === 41 /* Parameter */) {
+                else if (decl.node.nodeType === 41 /* ParseNodeType.Parameter */) {
                     nameNode = decl.node.name;
                     // Don't emit a diagnostic for unused parameters or type parameters.
                     diagnosticLevel = 'none';
@@ -2390,7 +2444,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     message = localize_1.Localizer.Diagnostic.unaccessedVariable().format({ name: nameNode.value });
                 }
                 break;
-            case 6 /* Class */:
+            case 6 /* DeclarationType.Class */:
                 if (!isPrivate) {
                     return;
                 }
@@ -2404,7 +2458,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
                 message = localize_1.Localizer.Diagnostic.unaccessedClass().format({ name: nameNode.value });
                 break;
-            case 5 /* Function */:
+            case 5 /* DeclarationType.Function */:
                 if (!isPrivate) {
                     return;
                 }
@@ -2418,18 +2472,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
                 message = localize_1.Localizer.Diagnostic.unaccessedFunction().format({ name: nameNode.value });
                 break;
-            case 3 /* TypeParameter */:
+            case 3 /* DeclarationType.TypeParameter */:
                 // Never report a diagnostic for an unused TypeParameter.
                 diagnosticLevel = 'none';
                 nameNode = decl.node.name;
                 break;
-            case 0 /* Intrinsic */:
-            case 7 /* SpecialBuiltInClass */:
+            case 0 /* DeclarationType.Intrinsic */:
+            case 7 /* DeclarationType.SpecialBuiltInClass */:
                 return;
             default:
                 (0, debug_1.assertNever)(decl);
         }
-        const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* unusedImport */ } : undefined;
+        const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* Commands.unusedImport */ } : undefined;
         if (nameNode) {
             this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
             if (rule !== undefined && message) {
@@ -2441,7 +2495,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // common source of programming errors. Also validates that arguments passed
     // to isinstance or issubclass won't generate exceptions.
     _validateIsInstanceCall(node) {
-        if (node.leftExpression.nodeType !== 38 /* Name */ ||
+        if (node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
             (node.leftExpression.value !== 'isinstance' && node.leftExpression.value !== 'issubclass') ||
             node.arguments.length !== 2) {
             return;
@@ -2487,7 +2541,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // it's unnecessary.
         let curNode = node;
         while (curNode) {
-            if (curNode.nodeType === 2 /* Assert */) {
+            if (curNode.nodeType === 2 /* ParseNodeType.Assert */) {
                 return;
             }
             curNode = curNode.parent;
@@ -2651,11 +2705,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
             switch (subtype.category) {
-                case 2 /* Any */:
-                case 1 /* Unknown */:
-                case 0 /* Unbound */:
+                case 2 /* TypeCategory.Any */:
+                case 1 /* TypeCategory.Unknown */:
+                case 0 /* TypeCategory.Unbound */:
                     break;
-                case 6 /* Class */:
+                case 6 /* TypeCategory.Class */:
                     if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noneNotAllowed());
                         isSupported = false;
@@ -2676,13 +2730,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         isSupported = false;
                     }
                     break;
-                case 4 /* Function */:
+                case 4 /* TypeCategory.Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
                     break;
-                case 9 /* TypeVar */:
+                case 9 /* TypeCategory.TypeVar */:
                     diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
                     isSupported = false;
                     break;
@@ -2693,7 +2747,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _isSymbolPrivate(nameValue, scopeType) {
         // All variables within the scope of a function or a list
         // comprehension are considered private.
-        if (scopeType === 1 /* Function */ || scopeType === 0 /* ListComprehension */) {
+        if (scopeType === 1 /* ScopeType.Function */ || scopeType === 0 /* ScopeType.ListComprehension */) {
             return true;
         }
         // See if the symbol is private.
@@ -2702,11 +2756,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (SymbolNameUtils.isProtectedName(nameValue)) {
             // Protected names outside of a class scope are considered private.
-            const isClassScope = scopeType === 2 /* Class */;
+            const isClassScope = scopeType === 2 /* ScopeType.Class */;
             return !isClassScope;
         }
         return false;
     }
+    _reportDeprecatedClassProperty(node, functionTypeResult) {
+        if (!(0, types_1.isClassInstance)(functionTypeResult.decoratedType) ||
+            !types_1.ClassType.isClassProperty(functionTypeResult.decoratedType)) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node.name, localize_1.Localizer.Diagnostic.classPropertyDeprecated());
+    }
     _reportDeprecatedUseForMemberAccess(node, info) {
         let errorMessage;
         if (info.accessType === 'property') {
@@ -2744,7 +2805,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let deprecatedMessage;
         function getDeprecatedMessageForFunction(functionType) {
             if (functionType.details.declaration &&
-                functionType.details.declaration.node.nodeType === 28 /* Function */) {
+                functionType.details.declaration.node.nodeType === 28 /* ParseNodeType.Function */) {
                 const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
                 /* stopAtFunction */ true);
                 if (containingClass) {
@@ -2901,7 +2962,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Add a quick action that renames the file.
             if (diag) {
                 const renameAction = {
-                    action: "renameShadowedFile" /* RenameShadowedFileAction */,
+                    action: "renameShadowedFile" /* ActionKind.RenameShadowedFileAction */,
                     oldFile: this._fileInfo.filePath,
                     newFile: this._sourceMapper.getNextFileName(this._fileInfo.filePath),
                 };
@@ -2915,8 +2976,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Skip this check for relative imports.
-        const nodeModule = node.nodeType === 23 /* ImportFromAs */
-            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ImportFrom */
+        const nodeModule = node.nodeType === 23 /* ParseNodeType.ImportFromAs */
+            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */
                 ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.module
                 : undefined
             : node.module;
@@ -2924,9 +2985,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Otherwise use the name to determine if a match for a stdlib module.
-        const namePartNodes = node.nodeType === 21 /* ImportAs */
+        const namePartNodes = node.nodeType === 21 /* ParseNodeType.ImportAs */
             ? node.module.nameParts
-            : node.nodeType === 23 /* ImportFromAs */
+            : node.nodeType === 23 /* ParseNodeType.ImportFromAs */
                 ? [node.name]
                 : node.module.nameParts;
         const nameParts = namePartNodes.map((n) => n.value);
@@ -2952,7 +3013,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // Add a quick action that renames the file.
                     if (diag) {
                         const renameAction = {
-                            action: "renameShadowedFile" /* RenameShadowedFileAction */,
+                            action: "renameShadowedFile" /* ActionKind.RenameShadowedFileAction */,
                             oldFile: p,
                             newFile: this._sourceMapper.getNextFileName(p),
                         };
@@ -2972,7 +3033,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 /* Argument */ && node.parent.name === node) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* ParseNodeType.Argument */ && node.parent.name === node) {
             return;
         }
         const nameValue = node.value;
@@ -2988,7 +3049,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!primaryDeclaration || primaryDeclaration.node === node) {
             return;
         }
-        if (primaryDeclaration.type === 8 /* Alias */) {
+        if (primaryDeclaration.type === 8 /* DeclarationType.Alias */) {
             // If this symbol is an import alias (i.e. it's a local name rather than the
             // original imported name), skip the private check.
             if (primaryDeclaration.usesLocalName) {
@@ -3084,12 +3145,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         };
         suiteNode.statements.forEach((statement) => {
             if (!AnalyzerNodeInfo.isCodeUnreachable(statement)) {
-                if (statement.nodeType === 47 /* StatementList */) {
+                if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
                     for (const substatement of statement.statements) {
-                        if (substatement.nodeType !== 54 /* TypeAnnotation */ &&
-                            substatement.nodeType !== 18 /* Ellipsis */ &&
-                            substatement.nodeType !== 48 /* StringList */ &&
-                            substatement.nodeType !== 42 /* Pass */) {
+                        if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
+                            substatement.nodeType !== 18 /* ParseNodeType.Ellipsis */ &&
+                            substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
+                            substatement.nodeType !== 42 /* ParseNodeType.Pass */) {
                             emitBadStatementError(substatement);
                         }
                     }
@@ -3207,7 +3268,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateReturnTypeIsNotContravariant(returnType, errorNode) {
         let isContraTypeVar = false;
         (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
-            if ((0, types_1.isTypeVar)(subtype) && subtype.details.declaredVariance === 4 /* Contravariant */) {
+            if ((0, types_1.isTypeVar)(subtype) && subtype.details.declaredVariance === 4 /* Variance.Contravariant */) {
                 isContraTypeVar = true;
             }
         });
@@ -3229,7 +3290,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // as Final in parent classes.
     _validateFinalMemberOverrides(classType) {
         classType.details.fields.forEach((localSymbol, name) => {
-            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* SkipOriginalClass */);
+            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* MemberAccessFlags.SkipOriginalClass */);
             if (parentSymbol &&
                 (0, types_1.isInstantiableClass)(parentSymbol.classType) &&
                 this._evaluator.isFinalVariable(parentSymbol.symbol) &&
@@ -3252,7 +3313,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             const decls = symbol.getDeclarations();
-            if (decls.length >= 2 && decls[0].type === 1 /* Variable */) {
+            if (decls.length >= 2 && decls[0].type === 1 /* DeclarationType.Variable */) {
                 const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
                 // Is this symbol a literal instance of the enum class?
                 if ((0, types_1.isClassInstance)(symbolType) &&
@@ -3263,14 +3324,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    // If a non-protocol class explicitly inherits from a protocol class, this method
-    // verifies that any class or instance variables declared but not assigned
-    // in the protocol class are implemented in the subclass. It also checks that any
-    // empty functions declared in the protocol are implemented in the subclass.
+    // If a non-protocol class explicitly inherits from a protocol class and does
+    // not explicit derive from ABC, this method verifies that any class or instance
+    // variables declared but not assigned in the protocol class are implemented in
+    // the subclass. It also checks that any empty functions declared in the protocol
+    // are implemented in the subclass.
     _validateProtocolCompatibility(classType, errorNode) {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
+        // If a class derives from ABC, exempt it from this check. This is used for
+        // mixins that derive from a protocol but do not directly implement all
+        // of the protocol's methods.
+        if (classType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'ABC'))) {
+            return;
+        }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         const isSymbolImplemented = (name) => {
             return classType.details.mro.some((mroClass) => {
@@ -3287,10 +3355,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (decls.length === 0 || !(0, types_1.isClass)(member.classType)) {
                     return;
                 }
-                if (decls[0].type === 1 /* Variable */) {
+                if (decls[0].type === 1 /* DeclarationType.Variable */) {
                     // If none of the declarations involve assignments, assume it's
                     // not implemented in the protocol.
-                    if (!decls.some((decl) => decl.type === 1 /* Variable */ && !!decl.inferredTypeSource)) {
+                    if (!decls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
                         // This is a variable declaration that is not implemented in the
                         // protocol base class. Make sure it's implemented in the derived class.
                         if (!isSymbolImplemented(name)) {
@@ -3301,8 +3369,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                else if (decls[0].type === 5 /* Function */) {
-                    if (decls.every((decl) => decl.type !== 5 /* Function */ || ParseTreeUtils.isSuiteEmpty(decl.node.suite))) {
+                else if (decls[0].type === 5 /* DeclarationType.Function */) {
+                    if (decls.every((decl) => decl.type !== 5 /* DeclarationType.Function */ || ParseTreeUtils.isSuiteEmpty(decl.node.suite))) {
                         if ((0, pathUtils_1.getFileExtension)(decls[0].path).toLowerCase() !== '.pyi') {
                             if (!isSymbolImplemented(name)) {
                                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
@@ -3325,7 +3393,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.ClassType.isDataClass(classType)) {
             return;
         }
-        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 64 /* DeclaredTypesOnly */);
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* MemberAccessFlags.SkipBaseClasses */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
         // If there's no __post_init__ method, there's nothing to check.
         if (!postInitMember) {
             return;
@@ -3448,7 +3516,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // variables. We need to make sure these are initialized.
         const abstractSymbols = new Map();
         if (types_1.ClassType.isFinal(classType)) {
-            (0, typeUtils_1.getProtocolSymbolsRecursive)(classType, abstractSymbols, 1024 /* SupportsAbstractMethods */);
+            (0, typeUtils_1.getProtocolSymbolsRecursive)(classType, abstractSymbols, 1024 /* ClassTypeFlags.SupportsAbstractMethods */);
         }
         classType.details.fields.forEach((localSymbol, name) => {
             abstractSymbols.delete(name);
@@ -3465,14 +3533,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!containingClass) {
                     return true;
                 }
-                if (containingClass.nodeType === 10 /* Class */) {
+                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 /* Assignment */) {
+                    if (((_a = decl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */) {
                         return true;
                     }
-                    if (((_b = decl.node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 54 /* TypeAnnotation */ &&
-                        ((_c = decl.node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                    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 */) {
                         return true;
                     }
                     // If this is part of a dataclass or a class handled by a dataclass_transform,
@@ -3496,7 +3564,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // If the symbol is declared by its parent, we can assume it
             // is initialized there.
-            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* SkipOriginalClass */);
+            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* MemberAccessFlags.SkipOriginalClass */);
             if (parentSymbol) {
                 return;
             }
@@ -3511,10 +3579,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (decls.length === 0 || !(0, types_1.isClass)(member.classType)) {
                 return;
             }
-            if (decls[0].type === 1 /* Variable */) {
+            if (decls[0].type === 1 /* DeclarationType.Variable */) {
                 // If none of the declarations involve assignments, assume it's
                 // not implemented in the protocol.
-                if (!decls.some((decl) => decl.type === 1 /* Variable */ && !!decl.inferredTypeSource)) {
+                if (!decls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
                     // This is a variable declaration that is not implemented in the
                     // protocol base class. Make sure it's implemented in the derived class.
                     diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.uninitializedAbstractVariable().format({
@@ -3552,7 +3620,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             // Skip type variables with auto-variance.
-            if (param.details.declaredVariance === 0 /* Auto */) {
+            if (param.details.declaredVariance === 0 /* Variance.Auto */) {
                 return;
             }
             // Replace all type arguments with a dummy type except for the
@@ -3575,26 +3643,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const isDestSubtypeOfSrc = this._evaluator.assignClassToSelf(srcType, destType);
             let expectedVariance;
             if (isDestSubtypeOfSrc) {
-                expectedVariance = 3 /* Covariant */;
+                expectedVariance = 3 /* Variance.Covariant */;
             }
             else {
                 const isSrcSubtypeOfDest = this._evaluator.assignClassToSelf(destType, srcType);
                 if (isSrcSubtypeOfDest) {
-                    expectedVariance = 4 /* Contravariant */;
+                    expectedVariance = 4 /* Variance.Contravariant */;
                 }
                 else {
-                    expectedVariance = 2 /* Invariant */;
+                    expectedVariance = 2 /* Variance.Invariant */;
                 }
             }
             if (expectedVariance !== classType.details.typeParameters[paramIndex].details.declaredVariance) {
                 let message;
-                if (expectedVariance === 3 /* Covariant */) {
+                if (expectedVariance === 3 /* Variance.Covariant */) {
                     message = localize_1.Localizer.Diagnostic.protocolVarianceCovariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
                     });
                 }
-                else if (expectedVariance === 4 /* Contravariant */) {
+                else if (expectedVariance === 4 /* Variance.Contravariant */) {
                     message = localize_1.Localizer.Diagnostic.protocolVarianceContravariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
@@ -3624,13 +3692,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         classType.details.fields.forEach((symbol, name) => {
             const decls = symbol.getDeclarations();
-            const isDefinedBySlots = decls.some((decl) => decl.type === 1 /* Variable */ && decl.isDefinedBySlots);
+            const isDefinedBySlots = decls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && decl.isDefinedBySlots);
             if (isDefinedBySlots) {
                 decls.forEach((decl) => {
-                    if (decl.type === 1 /* Variable */ &&
+                    if (decl.type === 1 /* DeclarationType.Variable */ &&
                         !decl.isDefinedBySlots &&
                         !decl.isDefinedByMemberAccess) {
-                        if (decl.node.nodeType === 38 /* Name */ && ParseTreeUtils.isWriteAccess(decl.node)) {
+                        if (decl.node.nodeType === 38 /* ParseNodeType.Name */ && ParseTreeUtils.isWriteAccess(decl.node)) {
                             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.slotsClassVarConflict().format({ name }), decl.node);
                         }
                     }
@@ -3696,25 +3764,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // often has an *args and/or **kwargs. We'll also set the ParamSpecValue
         // because we don't care about the return type for this check.
         initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags |
-            32768 /* SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* ParamSpecValue */);
+            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
+            65536 /* FunctionTypeFlags.ParamSpecValue */);
         newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags |
-            32768 /* SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* ParamSpecValue */);
+            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
+            65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.details.declaration;
             const newDecl = newMemberType.details.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
-                const mainDeclNode = mainDecl.node.nodeType === 28 /* Function */ ? mainDecl.node.name : mainDecl.node;
+                const mainDeclNode = mainDecl.node.nodeType === 28 /* ParseNodeType.Function */ ? mainDecl.node.name : mainDecl.node;
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const initSignature = this._evaluator.printType(initMemberType);
                 const newSignature = this._evaluator.printType(newMemberType);
@@ -3897,7 +3965,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
-                    if (decl && decl.type === 5 /* Function */) {
+                    if (decl && decl.type === 5 /* DeclarationType.Function */) {
                         diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.baseClassMethodTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
@@ -3929,12 +3997,63 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // If the child class overrides this symbol with its own type, make sure
                     // the override is compatible with the overridden symbol. Otherwise use the
                     // override type.
-                    if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType)) {
+                    // Verify that the override type is assignable to (same or narrower than)
+                    // the declared type of the base symbol.
+                    const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
+                    let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : 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.isFrozenDataClass(overriddenClassAndSymbol.classType) &&
+                        overriddenClassAndSymbol.classType.details.dataClassEntries) {
+                        const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                        if (dataclassEntry) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overriddenTDEntry;
+                    if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
+                        overriddenTDEntry = overriddenClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (overrideClassAndSymbol.classType.details.typedDictEntries) {
+                        overrideTDEntry = overrideClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                    }
+                    if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
+                    /* diag */ undefined, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
                         }), errorNode);
                     }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        let isRequiredCompatible;
+                        let isReadOnlyCompatible = true;
+                        // If both classes are TypedDicts and they both define this field,
+                        // make sure the attributes are compatible.
+                        if (overriddenTDEntry.isReadOnly) {
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isReadOnlyCompatible = !overrideTDEntry.isReadOnly;
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            const message = overrideTDEntry.isRequired
+                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
+                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
+                        }
+                        else if (!isReadOnlyCompatible) {
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                                name: memberName,
+                            }), errorNode);
+                        }
+                    }
                 }
             }
         }
@@ -3983,7 +4102,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     continue;
                 }
                 (0, debug_1.assert)((0, types_1.isClass)(mroBaseClass));
-                const baseClassAndSymbol = (0, typeUtils_1.lookUpClassMember)(mroBaseClass, name, 0 /* Default */);
+                const baseClassAndSymbol = (0, typeUtils_1.lookUpClassMember)(mroBaseClass, name, 0 /* MemberAccessFlags.Default */);
                 if (!baseClassAndSymbol) {
                     continue;
                 }
@@ -4013,8 +4132,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.fgetFunction) {
-                overrideFunction = overrideType.fgetFunction;
+            if (overrideType.fgetInfo) {
+                overrideFunction = overrideType.fgetInfo.methodType;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4047,8 +4166,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.fgetFunction) {
-                overrideFunction = overrideType.fgetFunction;
+            if (overrideType.fgetInfo) {
+                overrideFunction = overrideType.fgetInfo.methodType;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4108,7 +4227,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.details.name,
-                            }) + diagAddendum.getString(), decl.type === 5 /* Function */ ? decl.node.name : decl.node);
+                            }) + diagAddendum.getString(), decl.type === 5 /* DeclarationType.Function */ ? decl.node.name : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
@@ -4120,7 +4239,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // Private names (starting with double underscore) are exempt from this check.
                     if (!SymbolNameUtils.isPrivateName(memberName) && types_1.FunctionType.isFinal(baseType)) {
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
-                        if (decl && decl.type === 5 /* Function */) {
+                        if (decl && decl.type === 5 /* DeclarationType.Function */) {
                             const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.details.name,
@@ -4168,9 +4287,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else {
                 const baseClassType = baseClass;
                 const propMethodInfo = [
-                    ['fget', (c) => c.fgetFunction],
-                    ['fset', (c) => c.fsetFunction],
-                    ['fdel', (c) => c.fdelFunction],
+                    ['fget', (c) => { var _a; return (_a = c.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+                    ['fset', (c) => { var _a; return (_a = c.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+                    ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
                 ];
                 propMethodInfo.forEach((info) => {
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -4206,7 +4325,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                             name: methodName,
                                         }));
                                         const decl = subclassMethodType.details.declaration;
-                                        if (decl && decl.type === 5 /* Function */) {
+                                        if (decl && decl.type === 5 /* DeclarationType.Function */) {
                                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                                                 name: memberName,
                                                 className: baseClassType.details.name,
@@ -4234,7 +4353,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 /* Variable */ && !primaryDecl.isFinal;
+                    let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : 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.isFrozenDataClass(baseClass) && baseClass.details.dataClassEntries) {
@@ -4243,10 +4362,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             isInvariant = false;
                         }
                     }
+                    let overriddenTDEntry;
+                    if (baseClass.details.typedDictEntries) {
+                        overriddenTDEntry = baseClass.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (childClassType.details.typedDictEntries) {
+                        overrideTDEntry = childClassType.details.typedDictEntries.get(memberName);
+                    }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
                     /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* EnforceInvariance */ : 0 /* Default */)) {
+                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         if (isInvariant) {
                             diagAddendum = new diagnostic_1.DiagnosticAddendum();
                             diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideIsInvariant());
@@ -4264,6 +4394,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
                         }
                     }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        // Make sure the required/not-required attribute is compatible.
+                        let isRequiredCompatible = true;
+                        if (overriddenTDEntry.isReadOnly) {
+                            // If the read-only flag is set, a not-required field can be overridden
+                            // by a required field, but not vice versa.
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            const message = overrideTDEntry.isRequired
+                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
+                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
+                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), 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(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                                name: memberName,
+                            }), lastDecl.node);
+                        }
+                    }
                     // Verify that there is not a Final mismatch.
                     const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
                     const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
@@ -4289,7 +4444,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         // If the subclass is declaring an inner class, we'll consider that
                         // to be a ClassVar.
-                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 6 /* Class */)) {
+                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 6 /* DeclarationType.Class */)) {
                             isClassVar = true;
                         }
                     }
@@ -4379,7 +4534,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (node.parameters[0].name) {
                         paramName = node.parameters[0].name.value;
                     }
-                    if (node.parameters[0].category !== 0 /* Simple */) {
+                    if (node.parameters[0].category !== 0 /* ParameterCategory.Simple */) {
                         firstParamIsSimple = false;
                     }
                 }
@@ -4425,9 +4580,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // it could be combined with other classes in a multi-inheritance
         // situation that effectively adds new superclasses that we don't know
         // about statically.
-        let effectiveFlags = 16 /* SkipInstanceMembers */ | 1 /* SkipOriginalClass */;
+        let effectiveFlags = 16 /* MemberAccessFlags.SkipInstanceMembers */ | 1 /* MemberAccessFlags.SkipOriginalClass */;
         if (types_1.ClassType.isFinal(classType)) {
-            effectiveFlags |= 4 /* SkipObjectBaseClass */;
+            effectiveFlags |= 4 /* MemberAccessFlags.SkipObjectBaseClass */;
         }
         const methodMember = (0, typeUtils_1.lookUpClassMember)(classType, methodType.details.name, effectiveFlags);
         if (!methodMember) {
@@ -4437,13 +4592,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Now scan the implementation of the method to determine whether
         // super().<method> has been called for all of the required base classes.
         const callNodeWalker = new ParseTreeUtils.CallNodeWalker((node) => {
-            if (node.leftExpression.nodeType === 35 /* MemberAccess */) {
+            if (node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 // Is it accessing the method by the same name?
                 if (node.leftExpression.memberName.value === methodType.details.name) {
                     const memberBaseExpr = node.leftExpression.leftExpression;
                     // Is it a "super" call?
-                    if (memberBaseExpr.nodeType === 9 /* Call */ &&
-                        memberBaseExpr.leftExpression.nodeType === 38 /* Name */ &&
+                    if (memberBaseExpr.nodeType === 9 /* ParseNodeType.Call */ &&
+                        memberBaseExpr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
                         memberBaseExpr.leftExpression.value === 'super') {
                         foundCallOfMember = true;
                     }
@@ -4493,7 +4648,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // If the method starts with a `*args: P.args`, skip the check.
-        if (paramInfo.category === 1 /* ArgsList */ &&
+        if (paramInfo.category === 1 /* ParameterCategory.ArgsList */ &&
             (0, types_1.isParamSpec)(paramInfo.type) &&
             paramInfo.type.paramSpecAccess === 'args') {
             return;
@@ -4645,7 +4800,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._moduleNode);
         const importModuleMap = new Map();
         importStatements.orderedImports.forEach((importStatement) => {
-            if (importStatement.node.nodeType === 22 /* ImportFrom */) {
+            if (importStatement.node.nodeType === 22 /* ParseNodeType.ImportFrom */) {
                 const symbolMap = new Map();
                 importStatement.node.imports.forEach((importFromAs) => {
                     // Ignore duplicates if they're aliased.
@@ -4678,7 +4833,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const regionComments = (0, regions_1.getRegionComments)(this._parseResults);
         const regionStack = [];
         regionComments.forEach((regionComment) => {
-            if (regionComment.type === 0 /* Region */) {
+            if (regionComment.type === 0 /* RegionCommentType.Region */) {
                 regionStack.push(regionComment);
             }
             else {