Allow (e as dynamic).foo() in avoid_dynamic_calls

The `(e as dynamic)` pattern is the intended workaround for intentional
dynamic calls. The lint currently allows this for property reads like
`(e as dynamic).foo` but disallows this for method invocations like `(e
as dynamic).foo()` because the latter falls into a case checking if the
`node.function` is the dynamic expression (to handle cases like
`(e as dynamic).call()`) but there it is no longer checking the right
expression for whether it is a cast.

Pull out an `_isExplicitCast` method to check for casts wrapped in
parenthesis. Use the explicit cast as a signal to bail earlier when
checking method invocations.

Change-Id: I77b1c28b38474cea018b61a3d0ebe38ead82378d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/390640
Commit-Queue: Nate Bosch <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Auto-Submit: Nate Bosch <[email protected]>

Author: natebosch

pkg/linter/CHANGELOG.md

@@ -8,6 +8,8 @@
 - new _(experimental)_ lint: `omit_obvious_local_variable_types`
 - new _(experimental)_ lint: `specify_nonobvious_local_variable_types`
 - new _(experimental)_ lint: `avoid_futureor_void`
+- update `avoid_dynamic_calls` to allow method invocations on a cast to
+  dynamic.
 
 # 3.5.0
 

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

@@ -115,6 +115,7 @@ class _Visitor extends SimpleAstVisitor<void> {
         return;
       }
     }
+    if (_isExplicitCast(node.realTarget)) return;
     var receiverWasDynamic = _reportIfDynamic(node.realTarget);
     if (!receiverWasDynamic) {
       var target = node.realTarget;
@@ -167,7 +168,7 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   bool _reportIfDynamic(Expression? node) {
     if (node == null || node.staticType is! DynamicType) return false;
-    if (node.unParenthesized is AsExpression) return false;
+    if (_isExplicitCast(node)) return false;
 
     rule.reportLint(node);
     return true;
@@ -176,7 +177,7 @@ class _Visitor extends SimpleAstVisitor<void> {
   void _reportIfDynamicOrFunction(Expression node, {DartType? staticType}) {
     staticType ??= node.staticType;
     if (staticType == null) return;
-    if (node.unParenthesized is AsExpression) return;
+    if (_isExplicitCast(node)) return;
     if (staticType is DynamicType || staticType.isDartCoreFunction) {
       rule.reportLint(node);
     }
@@ -195,4 +196,15 @@ class _Visitor extends SimpleAstVisitor<void> {
       }
     }
   }
+
+  /// Whether an expression matches a pattern to allow a dynamic call.
+  ///
+  /// This should only be used to check expressions which have a static type of
+  /// `dynamic` or `Function`.
+  ///
+  /// Expressions with a static type of `dynamic` can be used only if they are
+  /// expliticly a parenthesized cast (which must be to `dynamic` or `Function`
+  /// to be relevant).
+  static bool _isExplicitCast(Expression? node) =>
+      node?.unParenthesized is AsExpression;
 }

pkg/linter/test/rules/avoid_dynamic_calls_test.dart

@@ -539,6 +539,14 @@ void f(dynamic a) {
     ]);
   }
 
+  test_prefixedIdentifier_dynamicMethodCall_asDynamic() async {
+    await assertNoDiagnostics(r'''
+void f(Object? a) {
+  (a as dynamic).foo();
+}
+''');
+  }
+
   test_prefixedIdentifier_noSuchMethod() async {
     await assertNoDiagnostics(r'''
 void f(dynamic a, Invocation i) {