[linter] Expand on migrated avoid_returning_null_for_void tests

Also adjusts the lint implementation to avoid a few nullable types and non-null assertions.

Change-Id: I4199b8ebe94842613c7d8fb322c109c28f194f21
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/388500
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Auto-Submit: Parker Lougheed <[email protected]>

Author: parlough

pkg/linter/lib/src/rules/avoid_returning_null_for_void.dart

@@ -45,12 +45,12 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   @override
   void visitReturnStatement(ReturnStatement node) {
-    if (node.expression != null) {
-      _visit(node, node.expression);
+    if (node.expression case var nodeExpression?) {
+      _visit(node, nodeExpression);
     }
   }
 
-  void _visit(AstNode node, Expression? expression) {
+  void _visit(AstNode node, Expression expression) {
     if (expression is! NullLiteral) {
       return;
     }
@@ -59,20 +59,19 @@ class _Visitor extends SimpleAstVisitor<void> {
         (e) => e is FunctionExpression || e is MethodDeclaration);
     if (parent == null) return;
 
-    DartType? type;
-    bool? isAsync;
-    LintCode code;
-    if (parent is FunctionExpression) {
-      type = parent.declaredElement?.returnType;
-      isAsync = parent.body.isAsynchronous;
-      code = LinterLintCode.avoid_returning_null_for_void_from_function;
-    } else if (parent is MethodDeclaration) {
-      type = parent.declaredElement?.returnType;
-      isAsync = parent.body.isAsynchronous;
-      code = LinterLintCode.avoid_returning_null_for_void_from_method;
-    } else {
-      throw StateError('unexpected type');
-    }
+    var (type, isAsync, code) = switch (parent) {
+      FunctionExpression() => (
+          parent.declaredElement?.returnType,
+          parent.body.isAsynchronous,
+          LinterLintCode.avoid_returning_null_for_void_from_function,
+        ),
+      MethodDeclaration() => (
+          parent.declaredElement?.returnType,
+          parent.body.isAsynchronous,
+          LinterLintCode.avoid_returning_null_for_void_from_method,
+        ),
+      _ => throw StateError('Unexpected type'),
+    };
     if (type == null) return;
 
     if (!isAsync && type is VoidType) {

pkg/linter/test/rules/avoid_returning_null_for_void_test.dart

@@ -34,6 +34,12 @@ Future<void> f3f() async {
     ]);
   }
 
+  test_function_async_returnsFutureVoid_expressionBody_returnNothing() async {
+    await assertNoDiagnostics(r'''
+Future<void> f() async => print('');
+''');
+  }
+
   test_function_async_returnsFutureVoid_expressionBody_returnNull() async {
     await assertDiagnostics(r'''
 Future<void> f() async => null;
@@ -42,6 +48,36 @@ Future<void> f() async => null;
     ]);
   }
 
+  test_function_blockBody_conditional_returnNothing() async {
+    await assertNoDiagnostics(r'''
+void f(bool b) {
+  if (b) {
+    return;
+  }
+}
+''');
+  }
+
+  test_function_blockBody_conditional_returnNull() async {
+    await assertDiagnostics(r'''
+void f(bool b) {
+  if (b) {
+    return null;
+  }
+}
+''', [
+      lint(32, 12),
+    ]);
+  }
+
+  test_function_blockBody_returnNothing() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  return;
+}
+''');
+  }
+
   test_function_blockBody_returnNull() async {
     await assertDiagnostics(r'''
 void f() {
@@ -52,6 +88,12 @@ void f() {
     ]);
   }
 
+  test_function_expressionBody_returnNothing() async {
+    await assertNoDiagnostics(r'''
+void f() => print('');
+''');
+  }
+
   test_function_expressionBody_returnNull() async {
     await assertDiagnostics(r'''
 void f() => null;
@@ -60,6 +102,13 @@ void f() => null;
     ]);
   }
 
+  test_function_expressionBody_returnNullExpressionResult() async {
+    await assertNoDiagnostics(r'''
+Null get nullFromGetter => null;
+void f() => nullFromGetter;
+''');
+  }
+
   test_localFunction_async_returnsFutureVoid_blockBody_returnNull() async {
     await assertDiagnostics(r'''
 void f() {
@@ -94,7 +143,19 @@ void f() {
     ]);
   }
 
-  test_method_blockBody_async_returnsFutureVoid_blockBody_returnNull() async {
+  test_method_class_blockBody_returnNull() async {
+    await assertDiagnostics(r'''
+class C {
+  void m() {
+    return null;
+  }
+}
+''', [
+      lint(27, 12),
+    ]);
+  }
+
+  test_method_inClass_blockBody_async_returnsFutureVoid_blockBody_returnNull() async {
     await assertDiagnostics(r'''
 class C {
   Future<void> m() async {
@@ -106,15 +167,45 @@ class C {
     ]);
   }
 
-  test_method_blockBody_returnNull() async {
+  test_method_inExtension_blockBody_returnNull() async {
+    await assertDiagnostics(r'''
+extension E on int {
+  void f() {
+    return null;
+  }
+}
+''', [lint(38, 12)]);
+  }
+
+  test_method_inExtensionType_blockBody_returnNull() async {
+    await assertDiagnostics(r'''
+extension type E(int i) {
+  void f() {
+    return null;
+  }
+}
+''', [lint(43, 12)]);
+  }
+
+  test_method_inMixin_blockBody_returnNull() async {
+    await assertDiagnostics(r'''
+mixin M {
+  void f() {
+    return null;
+  }
+}
+''', [lint(27, 12)]);
+  }
+
+  test_staticMethod_inClass_blockBody_returnNull() async {
     await assertDiagnostics(r'''
 class C {
-  void m() {
+  static void m() {
     return null;
   }
 }
 ''', [
-      lint(27, 12),
+      lint(34, 12),
     ]);
   }
 }