[vm/ffi] Missing analyzer error for type argument in `Native.addressOf`

[halildurmus]

@dcharkes

Consider this code:

import 'dart:ffi';

@Native<Void Function(Pointer)>()
external void free(Pointer p);

@Native<Int32>()
external int x;

void main() {
  Native.addressOf<NativeFunction>(free); // No analyzer error but CFE reports error
  //     ^
  //  Error: Expected type 'NativeFunction<Function>' to be a valid and instantiated subtype of 'NativeType'.
  // - 'NativeFunction' is from 'dart:ffi'.
  // - 'Function' is from 'dart:core'.

  Native.addressOf<NativeFunction<Void Function(Pointer)>>(free); // No CFE error as expected

  Native.addressOf(x); // No analyzer error but CFE reports error
  //     ^
  //  Error: Expected type 'NativeType' to be a valid and instantiated subtype of 'NativeType'.
  // - 'NativeType' is from 'dart:ffi'.

  Native.addressOf<Int32>(x); // No CFE error as expected
}

• For native functions: If NativeFunction is used as a type argument for Native.addressOf, the analyzer doesn’t report any errors, but the CFE does.
• For native fields: If no type argument is provided, the analyzer again doesn’t flag it, but the CFE does.

I looked into the relevant code in ffi_verifier.dart, and the analyzer only checks if the type argument is assignable to the native type. This doesn’t seem right – it should be checking if the types are exactly equal.

Here’s the code that handles these checks:

• Native functions:

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

  Line 1709 in 5c313c7

  if (!typeSystem.isAssignableTo(nativeType, targetFunctionType,

• Native fields:

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

  Line 1734 in 5c313c7

  if (!typeSystem.isAssignableTo(nativeType, targetType)) {

If this sounds correct, I’d be happy to create a CL to fix it.

[dart-github-bot]

Summary: The Dart analyzer incorrectly handles Native.addressOf type arguments. It allows assignable types instead of requiring exact type matches, causing silent errors.

[dcharkes]

the analyzer only checks if the type argument is assignable to the native type. This doesn’t seem right – it should be checking if the types are exactly equal.

Let's see do we need exactly equal, or assignable? Maybe assignable is the right behavior. The resulting Pointer object would have a less precise type, meaning it can be passed in to less places where a pointer with a more specific type is required.

However, since we don't have type inference from the Dart type to the C type (which is the pointer type argument), it is very likely that one would want spell out the full type. So maybe requiring the exact mapping is better from a user experience point of view. 👍

Type inference should work:

import 'dart:ffi';

@Native<Void Function(Pointer<Void>)>()
external void free(Pointer<Void> p);

@Native<Int32>()
external int x;

void main() {
  Pointer<NativeFunction<Void Function(Pointer<Void>)>> pointer = Native.addressOf(free); // No error.

  NativeFinalizer(Native.addressOf(free)); // No error.
}

If this sounds correct, I’d be happy to create a CL to fix it.

❤️ 🚀

You should be able to add tests here:

• pkg/analyzer/test/src/diagnostics/ffi_native_test.dart
• tests/ffi/static_checks/vmspecific_static_checks_native_test.dart

[halildurmus]

Let's see do we need exactly equal, or assignable? Maybe assignable is the right behavior. The resulting Pointer object would have a less precise type, meaning it can be passed in to less places where a pointer with a more specific type is required.

Yeah, that was my first thought too. I tried relaxing the type check in the CFE, but it caused some crashes (IIRC it crashed when converting a native function to a Dart function. The type argument wasn’t precise enough after relaxing the check). Anyway, since type inference works fine, it’s not a big deal.

You should be able to add tests here:

Thanks!