@zzzen/pyright-internal 1.2.0-dev.20240526 → 1.2.0-dev.20240609

package/dist/analyzer/checker.js

@@ -102,7 +102,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
         if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
         }
         this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
         // Mark symbols accessed by __all__ as accessed.
@@ -493,7 +493,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -509,11 +509,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._validateIllegalDefaultParamInitializer(node);
         return true;
     }
-    visitListComprehension(node) {
+    visitComprehension(node) {
         this._scopedNodes.push(node);
         return true;
     }
-    visitListComprehensionIf(node) {
+    visitComprehensionIf(node) {
         this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
@@ -533,7 +533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.evaluateTypesForStatement(item);
         });
         if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidTypeForm, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
         }
         return true;
     }
@@ -701,7 +701,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.evaluateTypesForStatement(node);
             const exceptionType = this._evaluator.getType(node.typeExpression);
             if (exceptionType) {
-                this._validateExceptionType(exceptionType, node.typeExpression);
+                this._validateExceptionType(exceptionType, node.typeExpression, node.isExceptGroup);
             }
         }
         return true;
@@ -719,7 +719,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
                 if (type.tupleTypeArguments.length > 0) {
                     if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportAssertAlwaysTrue, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
                     }
                 }
             }
@@ -861,7 +861,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_12)) {
             let curNode = node;
             while (curNode) {
-                if (curNode.nodeType === 27 /* ParseNodeType.FormatString */) {
+                if (curNode.nodeType === 30 /* ParseNodeType.FormatString */) {
                     fStringContainers.push(curNode);
                 }
                 curNode = curNode.parent;
@@ -877,14 +877,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 unescapedResult.unescapeErrors.forEach((error) => {
                     if (error.errorType === 0 /* UnescapeErrorType.InvalidEscapeSequence */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.LocMessage.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.LocMessage.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
                     }
                 });
                 // Prior to Python 3.12, it was not allowed to include a slash in an f-string.
                 if (fStringContainers.length > 0) {
                     const escapeOffset = token.escapedValue.indexOf('\\');
                     if (escapeOffset >= 0) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringEscape(), { start, length: 1 });
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringEscape(), { start, length: 1 });
                     }
                 }
             });
@@ -901,7 +901,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.getType(node);
         }
         if (node.strings.length > 1 && !node.isParenthesized) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportImplicitStringConcatenation, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
         }
         return true;
     }
@@ -992,7 +992,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 importInfo.isImportFound &&
                 importInfo.importType !== 2 /* ImportType.Local */ &&
                 !this._fileInfo.isStubFile) {
-                this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
+                this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
             }
         }
         return true;
@@ -1024,7 +1024,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             break;
         }
         let isImportFromTyping = false;
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
             if (node.parent.module.leadingDots === 0 && node.parent.module.nameParts.length === 1) {
                 if (node.parent.module.nameParts[0].value === 'typing') {
                     isImportFromTyping = true;
@@ -1066,7 +1066,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     break;
                 }
             }
-            else if (typeVarScopeNode.nodeType === 28 /* ParseNodeType.Function */) {
+            else if (typeVarScopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
                 if (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
                     foundDuplicate = true;
@@ -1228,7 +1228,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             55 /* ParseNodeType.UnaryOperation */,
             7 /* ParseNodeType.BinaryOperation */,
             40 /* ParseNodeType.Number */,
-            11 /* ParseNodeType.Constant */,
+            14 /* ParseNodeType.Constant */,
             38 /* ParseNodeType.Name */,
             52 /* ParseNodeType.Tuple */,
         ];
@@ -1236,11 +1236,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (simpleExpressionTypes.some((nodeType) => nodeType === node.nodeType)) {
             reportAsUnused = true;
         }
-        else if (node.nodeType === 31 /* ParseNodeType.List */ ||
+        else if (node.nodeType === 34 /* ParseNodeType.List */ ||
             node.nodeType === 45 /* ParseNodeType.Set */ ||
-            node.nodeType === 15 /* ParseNodeType.Dictionary */) {
+            node.nodeType === 18 /* ParseNodeType.Dictionary */) {
             // Exclude comprehensions.
-            if (!node.entries.some((entry) => entry.nodeType === 32 /* ParseNodeType.ListComprehension */)) {
+            if (!node.entries.some((entry) => entry.nodeType === 11 /* ParseNodeType.Comprehension */)) {
                 reportAsUnused = true;
             }
         }
@@ -1605,7 +1605,7 @@ 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 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ParseNodeType.Ellipsis */;
                     if (!existingEntry) {
                         localTypeVarUsage.set(nameType.details.name, {
                             nodes: [nameNode],
@@ -1637,7 +1637,7 @@ 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 /* ParseNodeType.Ellipsis */;
+                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 21 /* ParseNodeType.Ellipsis */;
                     const isExempt = !!nameType.details.isDefaultExplicit;
                     if (!existingEntry) {
                         classTypeVarUsage.set(nameType.details.name, {
@@ -1799,8 +1799,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
             if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
-                const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
-                const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+                const prevReturnType = types_1.FunctionType.getEffectiveReturnType(prevOverload);
+                const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
@@ -1901,15 +1901,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateStubStatement(statement) {
         switch (statement.nodeType) {
-            case 19 /* ParseNodeType.If */:
-            case 28 /* ParseNodeType.Function */:
+            case 22 /* ParseNodeType.If */:
+            case 31 /* ParseNodeType.Function */:
             case 10 /* ParseNodeType.Class */:
             case 0 /* ParseNodeType.Error */: {
                 // These are allowed in a stub file.
                 break;
             }
             case 57 /* ParseNodeType.While */:
-            case 26 /* ParseNodeType.For */:
+            case 29 /* ParseNodeType.For */:
             case 53 /* ParseNodeType.Try */:
             case 58 /* ParseNodeType.With */: {
                 // These are not allowed.
@@ -1924,15 +1924,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         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 14 /* ParseNodeType.Constant */:
+                        case 17 /* ParseNodeType.Del */:
+                        case 18 /* ParseNodeType.Dictionary */:
+                        case 27 /* ParseNodeType.Index */:
+                        case 29 /* ParseNodeType.For */:
+                        case 30 /* ParseNodeType.FormatString */:
+                        case 32 /* ParseNodeType.Global */:
+                        case 33 /* ParseNodeType.Lambda */:
+                        case 34 /* ParseNodeType.List */:
                         case 35 /* ParseNodeType.MemberAccess */:
                         case 38 /* ParseNodeType.Name */:
                         case 39 /* ParseNodeType.Nonlocal */:
@@ -1978,13 +1978,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _validateExceptionTypeRecursive(exceptionType, diag, baseExceptionType, allowTuple) {
+    _validateExceptionTypeRecursive(exceptionType, diag, baseExceptionType, baseExceptionGroupType, allowTuple, isExceptGroup) {
         const derivesFromBaseException = (classType) => {
             if (!baseExceptionType || !(0, types_1.isInstantiableClass)(baseExceptionType)) {
                 return true;
             }
             return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionType, /* ignoreUnknown */ false);
         };
+        const derivesFromBaseExceptionGroup = (classType) => {
+            if (!baseExceptionGroupType || !(0, types_1.isInstantiableClass)(baseExceptionGroupType)) {
+                return true;
+            }
+            return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionGroupType, /* ignoreUnknown */ false);
+        };
         (0, typeUtils_1.doForEachSubtype)(exceptionType, (exceptionSubtype) => {
             if ((0, types_1.isAnyOrUnknown)(exceptionSubtype)) {
                 return;
@@ -1996,12 +2002,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             type: this._evaluator.printType(exceptionSubtype),
                         }));
                     }
+                    if (isExceptGroup && derivesFromBaseExceptionGroup(exceptionSubtype)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionGroupTypeIncorrect());
+                    }
                     return;
                 }
                 if (allowTuple && exceptionSubtype.tupleTypeArguments) {
                     exceptionSubtype.tupleTypeArguments.forEach((typeArg) => {
-                        this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, 
-                        /* allowTuple */ false);
+                        this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, baseExceptionGroupType, 
+                        /* allowTuple */ false, isExceptGroup);
                     });
                     return;
                 }
@@ -2011,10 +2020,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    _validateExceptionType(exceptionType, errorNode) {
+    _validateExceptionType(exceptionType, errorNode, isExceptGroup) {
         const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
+        const baseExceptionGroupType = this._evaluator.getBuiltInType(errorNode, 'BaseExceptionGroup');
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-        this._validateExceptionTypeRecursive(exceptionType, diagAddendum, baseExceptionType, /* allowTuple */ true);
+        this._validateExceptionTypeRecursive(exceptionType, diagAddendum, baseExceptionType, baseExceptionGroupType, 
+        /* allowTuple */ true, isExceptGroup);
         if (!diagAddendum.isEmpty()) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.exceptionTypeNotClass().format({
                 type: this._evaluator.printType(exceptionType),
@@ -2175,7 +2186,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             // the assignment is within an `__init__` method, so ignore class
                             // scopes here.
                             const classOrFunc = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
-                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 28 /* ParseNodeType.Function */) {
+                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 31 /* ParseNodeType.Function */) {
                                 exemptAssignment = true;
                             }
                         }
@@ -2454,7 +2465,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             case 8 /* DeclarationType.Alias */:
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
-                if (decl.node.nodeType === 21 /* ParseNodeType.ImportAs */) {
+                if (decl.node.nodeType === 24 /* 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.
@@ -2471,12 +2482,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             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.LocMessage.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.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
+                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
                             return;
                         }
                     }
                 }
-                else if (decl.node.nodeType === 23 /* ParseNodeType.ImportFromAs */) {
+                else if (decl.node.nodeType === 26 /* 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.
@@ -2908,7 +2919,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 === 2 /* ScopeType.Function */ || scopeType === 1 /* ScopeType.ListComprehension */) {
+        if (scopeType === 2 /* ScopeType.Function */ || scopeType === 1 /* ScopeType.Comprehension */) {
             return true;
         }
         // See if the symbol is private.
@@ -2966,7 +2977,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let deprecatedMessage;
         function getDeprecatedMessageForFunction(functionType) {
             if (functionType.details.declaration &&
-                functionType.details.declaration.node.nodeType === 28 /* ParseNodeType.Function */) {
+                functionType.details.declaration.node.nodeType === 31 /* ParseNodeType.Function */) {
                 const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
                 /* stopAtFunction */ true);
                 if (containingClass) {
@@ -3134,7 +3145,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._importResolver.isStdlibModule(desc, this._fileInfo.executionEnvironment) &&
             this._sourceMapper.isUserCode(this._fileInfo.fileUri)) {
             // This means the user has a module that is overwriting the stdlib module.
-            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
+            const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.LocMessage.stdlibModuleOverridden().format({
                 name: moduleName,
                 path: this._fileInfo.fileUri.toUserVisibleString(),
             }), this._moduleNode);
@@ -3155,8 +3166,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Skip this check for relative imports.
-        const nodeModule = node.nodeType === 23 /* ParseNodeType.ImportFromAs */
-            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ParseNodeType.ImportFrom */
+        const nodeModule = node.nodeType === 26 /* ParseNodeType.ImportFromAs */
+            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */
                 ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.module
                 : undefined
             : node.module;
@@ -3164,9 +3175,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 /* ParseNodeType.ImportAs */
+        const namePartNodes = node.nodeType === 24 /* ParseNodeType.ImportAs */
             ? node.module.nameParts
-            : node.nodeType === 23 /* ParseNodeType.ImportFromAs */
+            : node.nodeType === 26 /* ParseNodeType.ImportFromAs */
                 ? [node.name]
                 : node.module.nameParts;
         const nameParts = namePartNodes.map((n) => n.value);
@@ -3321,7 +3332,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
                     for (const substatement of statement.statements) {
                         if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
-                            substatement.nodeType !== 18 /* ParseNodeType.Ellipsis */ &&
+                            substatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
                             substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
                             substatement.nodeType !== 42 /* ParseNodeType.Pass */) {
                             emitBadStatementError(substatement);
@@ -3540,11 +3551,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         types_1.ClassType.getSymbolTable(classType).forEach((symbol, name) => {
             var _a;
-            // Enum members don't have type annotations.
-            if (symbol.getTypedDeclarations().length > 0) {
-                return;
-            }
-            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name);
+            // Determine whether this is an enum member. We ignore the presence
+            // of an annotation in this case because the runtime does. From a
+            // type checking perspective, if the runtime treats the assignment
+            // as an enum member but there is a type annotation present, it is
+            // considered a type checking error.
+            const symbolType = (0, enums_1.transformTypeForEnumMember)(this._evaluator, classType, name, 
+            /* ignoreAnnotation */ true);
             // Is this symbol a literal instance of the enum class?
             if (!symbolType ||
                 !(0, types_1.isClassInstance)(symbolType) ||
@@ -3552,6 +3565,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 !(symbolType.literalValue instanceof types_1.EnumLiteral)) {
                 return;
             }
+            // Enum members should not have type annotations.
+            const typedDecls = symbol.getTypedDeclarations();
+            if (typedDecls.length > 0) {
+                if (typedDecls[0].type === 1 /* DeclarationType.Variable */ && typedDecls[0].inferredTypeSource) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumMemberTypeAnnotation(), typedDecls[0].node);
+                }
+                return;
+            }
             // Look for a duplicate assignment.
             const decls = symbol.getDeclarations();
             if (decls.length >= 2 && decls[0].type === 1 /* DeclarationType.Variable */) {
@@ -3978,12 +3999,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // We'll set the "SkipArgsKwargs" flag for pragmatic reasons since __new__
         // 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 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* FunctionTypeFlags.ParamSpecValue */);
-        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags |
-            32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ |
-            65536 /* FunctionTypeFlags.ParamSpecValue */);
+        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
+        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
@@ -3997,7 +4014,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const newDecl = newMemberType.details.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
-                const mainDeclNode = mainDecl.node.nodeType === 28 /* ParseNodeType.Function */ ? mainDecl.node.name : mainDecl.node;
+                const mainDeclNode = mainDecl.node.nodeType === 31 /* 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);
@@ -5068,7 +5085,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!functionTypeResult) {
             return;
         }
-        const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionTypeResult.functionType);
+        const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
         if (!declaredReturnType) {
             return;
         }
@@ -5178,7 +5195,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 /* ParseNodeType.ImportFrom */) {
+            if (importStatement.node.nodeType === 25 /* ParseNodeType.ImportFrom */) {
                 const symbolMap = new Map();
                 importStatement.node.imports.forEach((importFromAs) => {
                     // Ignore duplicates if they're aliased.