@zzzen/pyright-internal 1.2.0-dev.20221002 → 1.2.0-dev.20221016

package/dist/analyzer/checker.js

@@ -533,6 +533,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // There is no return expression, so "None" is assumed.
             returnType = types_1.NoneType.createInstance();
         }
+        // If the enclosing function is async and a generator, the return
+        // statement is not allowed to have an argument. A syntax error occurs
+        // at runtime in this case.
+        if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.isAsync) && node.returnExpression) {
+            const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
+            if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* Function */ && functionDecl.isGenerator) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.returnInAsyncGenerator(), node.returnExpression);
+            }
+        }
         if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined) && enclosingFunctionNode) {
             if (declaredReturnType) {
                 if ((0, types_1.isNever)(declaredReturnType)) {
@@ -3341,6 +3350,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, types_1.isAnyOrUnknown)(typeOfSymbol)) {
                 return;
             }
+            let foundOverride = false;
             for (const baseClass of classType.details.baseClasses) {
                 if (!(0, types_1.isClass)(baseClass)) {
                     continue;
@@ -3355,10 +3365,35 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!baseClassAndSymbol) {
                     continue;
                 }
+                foundOverride = true;
                 this._validateBaseClassOverride(baseClassAndSymbol, symbol, typeOfSymbol, classType, name);
             }
+            if (!foundOverride) {
+                // If this is a method decorated with @override, validate that there
+                // is a base class method of the same name.
+                this._validateOverrideDecorator(typeOfSymbol);
+            }
         });
     }
+    // Determines whether the type is a function or overloaded function with an @override
+    // decorator. In this case, an error is reported because no base class has declared
+    // a method of the same name.
+    _validateOverrideDecorator(overrideType) {
+        let overrideFunction;
+        if ((0, types_1.isFunction)(overrideType)) {
+            overrideFunction = overrideType;
+        }
+        else if ((0, types_1.isOverloadedFunction)(overrideType)) {
+            overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
+        }
+        if (!overrideFunction ||
+            !types_1.FunctionType.isOverridden(overrideFunction) ||
+            !overrideFunction.details.declaration) {
+            return;
+        }
+        const funcNode = overrideFunction.details.declaration.node;
+        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overrideNotFound().format({ name: funcNode.name.value }), funcNode.name);
+    }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;