[analyzer/ffi] Handle NativeCallable arguments independently of source order

Closes #63871

GitOrigin-RevId: 5aa023a
Change-Id: Ic1c13632654588ad3f8c459a51623958ee4dba80
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/526980
Reviewed-by: Daco Harkes <dacoharkes@google.com>
Commit-Queue: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

Author: Yusufihsangorgel

pkg/analyzer/lib/src/generated/ffi_verifier.dart

@@ -1937,7 +1937,24 @@ class FfiVerifier extends RecursiveAstVisitor2<void> {
       return;
     }
 
-    var f = node.argumentList.arguments2[0];
+    ArgumentImpl? f;
+    NamedArgumentImpl? exceptionalReturn;
+    for (var argument in node.argumentList.arguments2) {
+      if (argument is NamedArgumentImpl) {
+        exceptionalReturn = argument;
+      } else if (f == null) {
+        f = argument;
+      } else {
+        // There are other diagnostics reported against the invocation and the
+        // diagnostics generated below might be inaccurate, so don't report
+        // them.
+        return;
+      }
+    }
+    if (f == null) {
+      return;
+    }
+
     var funcType = f.argumentExpression2.typeOrThrow;
     if (!_validateCompatibleFunctionTypes(
       _FfiTypeCheckDirection.dartToNative,
@@ -1962,20 +1979,19 @@ class FfiVerifier extends RecursiveAstVisitor2<void> {
           natRetType.isPointer ||
           natRetType.isHandle ||
           natRetType.isCompoundSubtype) {
-        if (argCount != 1) {
+        if (exceptionalReturn != null) {
           _diagnosticReporter.report(
             diag.invalidExceptionValue
                 .withArguments(methodName: name)
-                .at(node.argumentList.arguments2[1]),
+                .at(exceptionalReturn),
           );
         }
-      } else if (argCount != 2) {
+      } else if (exceptionalReturn == null) {
         _diagnosticReporter.report(
           diag.missingExceptionValue.withArguments(methodName: name).at(node),
         );
       } else {
-        var e = (node.argumentList.arguments2[1] as NamedArgument)
-            .argumentExpression2;
+        var e = exceptionalReturn.argumentExpression2;
         var eType = e.typeOrThrow;
         if (!_validateCompatibleNativeType(
           _FfiTypeCheckDirection.dartToNative,

pkg/analyzer/test/src/diagnostics/ffi_async_callback_test.dart

@@ -28,6 +28,19 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_argumentMustBeAConstant_namedFirst() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+int f(int i) => i * 2;
+void g() {
+  int e = 123;
+  NativeCallable<Int32 Function(Int32)>.isolateLocal(exceptionalReturn: e, f);
+//                                                                      ^
+// [diag.argumentMustBeAConstant] Argument 'exceptionalReturn' must be a constant.
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_exceptionMustBeASubtype() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';
@@ -40,6 +53,18 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_exceptionMustBeASubtype_namedFirst() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+int f(int i) => i * 2;
+void g() {
+  NativeCallable<Int32 Function(Int32)>.isolateLocal(exceptionalReturn: '?', f);
+//                                                                      ^^^
+// [diag.mustBeASubtype] The type 'String' must be a subtype of 'Int32' for 'isolateLocal'.
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_inferred() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';
@@ -64,6 +89,29 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_invalidExceptionValue_namedFirst() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+void f(int i) => i * 2;
+void g() {
+  NativeCallable<Void Function(Int32)>.isolateLocal(exceptionalReturn: 4, f);
+//                                                  ^^^^^^^^^^^^^^^^^^^^
+// [diag.invalidExceptionValue] The method isolateLocal can't have an exceptional return value (the second argument) when the return type of the function is either 'void', 'Handle' or 'Pointer'.
+}
+''');
+  }
+
+  test_NativeCallable_isolateLocal_missingCallback() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+void g() {
+  NativeCallable<Int32 Function(Int32)>.isolateLocal(exceptionalReturn: 0);
+//                                                   ^^^^^^^^^^^^^^^^^
+// [diag.notEnoughPositionalArgumentsNameSingular] 1 positional argument expected by 'isolateLocal', but 0 found.
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_missingExceptionValue() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';
@@ -100,6 +148,18 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_mustBeASubtype_namedFirst() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+int f(int i) => i * 2;
+void g() {
+  NativeCallable<Int32 Function(Double)>.isolateLocal(exceptionalReturn: 4, f);
+//                                                                          ^
+// [diag.mustBeASubtype] The type 'int Function(int)' must be a subtype of 'Int32 Function(Double)' for 'NativeCallable'.
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_mustHaveTypeArgs() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';
@@ -122,6 +182,16 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_ok_namedFirst() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+int f(int i) => i * 2;
+void g() {
+  NativeCallable<Int32 Function(Int32)>.isolateLocal(exceptionalReturn: 4, f);
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_okVoid() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';
@@ -132,6 +202,30 @@ void g() {
 ''');
   }
 
+  test_NativeCallable_isolateLocal_positionalExceptionalReturn() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+int f(int i) => i * 2;
+void g() {
+  NativeCallable<Int32 Function(Int32)>.isolateLocal(f, 0);
+//                                                      ^
+// [diag.extraPositionalArgumentsCouldBeNamed] Too many positional arguments: 1 expected, but 2 found.
+}
+''');
+  }
+
+  test_NativeCallable_isolateLocal_positionalExceptionalReturn_void() async {
+    await resolveTestCodeWithDiagnostics(r'''
+import 'dart:ffi';
+void f(int i) => i * 2;
+void g() {
+  NativeCallable<Void Function(Int32)>.isolateLocal(f, 0);
+//                                                     ^
+// [diag.extraPositionalArgumentsCouldBeNamed] Too many positional arguments: 1 expected, but 2 found.
+}
+''');
+  }
+
   test_NativeCallable_isolateLocal_voidReturnPermissive() async {
     await resolveTestCodeWithDiagnostics(r'''
 import 'dart:ffi';