Dart FFI：lookup/asFunction无法接收继承NativeType的泛型类型

为什么<T extends NativeType>无法编译？ #

Dart FFI对NativeFunction的签名有严格的编译期检查要求：签名中的所有原生类型必须是编译期可确定的具体类型（比如Int8、Pointer<Int32>），不能是泛型参数。

当你使用<T extends NativeType>作为Pointer<T>的类型参数时，T是一个运行时类型变量，编译期无法确定它对应的具体原生类型，FFI无法生成对应的机器码绑定，因此会报错提示签名无效。

而直接替换为NativeType时，它是所有原生类型的顶层基类，编译期能识别为合法的原生类型占位符，因此可以通过编译，但这本质是绕过了类型安全检查：

• 它丢失了具体的类型信息，无法保证传入的指针类型与C函数期望的一致；
• 当T不作为指针使用时（比如直接用Int8作为函数参数），NativeFunction<Void Function(NativeType)>会直接编译失败，因为C函数不接受抽象的原生基类作为参数。

正确使用泛型的解决方案 #

由于FFI需要编译期确定的具体类型，我们可以通过泛型配合类型分支或预定义类型别名的方式实现类型安全的泛型查找函数。

方案1：预定义类型别名+类型分支 #

通过为每个支持的原生类型预定义对应的NativeFunction别名，在泛型函数内部根据T的具体类型选择对应的签名：

import 'dart:ffi';

// 为每个支持的类型预定义NativeFunction别名
typedef NativeVoidFuncInt8 = NativeFunction<Void Function(Pointer<Int8>)>;
typedef NativeVoidFuncInt32 = NativeFunction<Void Function(Pointer<Int32>)>;
typedef NativeVoidFuncFloat = NativeFunction<Void Function(Float)>;

// Dart侧函数类型的泛型别名
typedef DartFunc<T extends NativeType> = T extends Pointer<infer U> 
    ? void Function(Pointer<U>) 
    : void Function(T);

(NativeFunction, DartFunc<T>) lookupGeneric<T extends NativeType>() {
  final dylib = DynamicLibrary.open("path");
  late final NativeFunction address;
  late final DartFunc<T> function;

  // 根据具体类型选择对应的NativeFunction
  if (T == Int8 || T == Pointer<Int8>) {
    address = dylib.lookup<NativeVoidFuncInt8>("Name");
    function = address.asFunction<void Function(Pointer<Int8>)>() as DartFunc<T>;
  } else if (T == Int32 || T == Pointer<Int32>) {
    address = dylib.lookup<NativeVoidFuncInt32>("Name");
    function = address.asFunction<void Function(Pointer<Int32>)>() as DartFunc<T>;
  } else if (T == Float) {
    address = dylib.lookup<NativeVoidFuncFloat>("Name");
    function = address.asFunction<void Function(Float)>() as DartFunc<T>;
  } else {
    throw UnsupportedError("不支持的原生类型: $T");
  }

  return (address, function);
}

void main() {
  final func1 = lookupGeneric<Pointer<Int8>>();
  final func2 = lookupGeneric<Float>();
}

方案2：使用Type参数配合编译期断言 #

如果需要更灵活的泛型支持，可以通过传递Type参数并配合编译期断言来确保类型安全：

import 'dart:ffi';

typedef NativeFunc<T extends NativeType> = NativeFunction<Void Function(T)>;
typedef DartFunc<T extends NativeType> = void Function(T);

(NativeFunction, DartFunc<T>) lookupGeneric<T extends NativeType>({required String symbolName}) {
  final dylib = DynamicLibrary.open("path");
  
  // 编译期断言确保T是具体的原生类型
  assert([Int8, Int32, Float, Pointer<Int8>].contains(T), "不支持的类型");
  
  // 借助dynamic绕过编译期检查，运行时确保类型正确
  final address = dylib.lookup<NativeFunc<T>>(symbolName) as NativeFunction;
  final function = address.asFunction<DartFunc<T>>(isLeaf: false);
  
  return (address, function);
}

void main() {
  final func = lookupGeneric<Pointer<Int8>>(symbolName: "Name");
}

注意：方案2中使用dynamic绕过了编译期检查，需要通过断言或文档明确支持的类型，避免运行时错误。

内容的提问来源于stack exchange，提问作者petiaccja