std.builtin.TypeInfo.Declaration.data.Fn.arg_names is empty

I'm trying to integrate zig with dart. Dart supports ffi with C. For the purposes of my project, zig would be a better choice than C. I need only 1-way calling : dart -> zig.
To make this possible, I have to generate a bit of glue code for dart. It would be enough for me to be able to get @typeInfo for my zig functions that includes the argument names and argument types. Currently, @typeInfo does not seem to provide this information.
Is there any workaround?

[LemonBoy]

The argument types are available and so are the argument names.

Sorry for the stupid question, but I'm new to zig (2 days of experience with the language), and from tutorials, I got only the reference to @typeInfo, but argument names are in Declaration, and I have no clue how I can get a Declaration based on FnArg I have. I can't see Declaration among the fields of FnArg

[data-man]

Related: #6530

Probably it's indeed related somehow, but maybe you can answer my question directly? I browsed through the "related" thing, don't have a clue how it can help me. I'm doing a very important experiment in the history of dart language, no one has ever tried to integrate it with zig and 99.9% of dart users never heard of it, to begin with, and even if they heard, they heard it from me!. In case of success, my plan was to start spamming dart mailing list extolling the virtues of a new language and alleging that it fits perfectly into ffi framework etc.. But I can't get ahold of a damn Declaration, without which not only can't I accomplish my plan - I can't even start putting it in motion! 😢

[SpexGuy]

maybe you can answer my question directly?

You can't obtain the argument names directly from function type info. Argument names are not part of function types. Instead, you need to pull arguments from a specific function declaration site. To do this, you must find the Declaration entry in the declaring type. There is no other way. So for example:

const Foo = struct {
  pub fn myFunc(a: u32) void {}
};
comptime {
  // get info for declaring type
  const info = @typeInfo(Foo);
  // get the myFunc decl.  There's only one.
  const decl = info.Struct.decls[0];
  // get the argument names
  const args = decl.data.Fn.arg_names;
  // args is [_][]const u8{ "a" }
}

So in order to get the names of function arguments, I have to declare this function inside some Struct? And it won't work for a standalone function? E.g. I have

pub fn myFunction(m: usize, N: i32) u32 {
   //...
}

Do I have to put it into a struct?
Actually, that's not that bad, Foo may as well serve as a namespace, but that's a bit weird, isn't it?
And what about the types of arguments? Will I get them from @typeInfo? Like

const t=@TypeOf(Foo.myFunc);
const typeInfo = @typeInfo(t);
const myArgs = typeInfo.Fn.args;
// and from there, I get all types

Right?

[SpexGuy]

The top-level of any file is itself a struct. You can use @This() to access that struct. It's also the type returned from @import when you import the file.

The argument types are stored in the type info for the function type.

[data-man]

There is no other way.

std.meta.declarations(@This())
?

Yes, @This() works! And std.meta.declarations(@This()) works, too. Thanks a lot!

Everything works, except arg_names. The list of arg_names is always empty

const Foo = struct {
  pub fn myFunc(a: u32, b:u32, c:u32) void {}
};

| *"fn_type=", fn(u32, u32, u32) void
| *"type info=", (struct std.builtin.Fn constant)
| *"return_type=", void
| *"is_export=", false
| *"is_extern=", false
| *"is_var_args=", false
| *"arg_names.len=", 0