Created attachment 121432 [details] [review]
Allow TypeSymbols in emitted C code for some C library macros

The attached patch to vala 0.3.5 allows vala to emit naked type symbols
as arguments to ellipses functions.
(The ellipses is really a red-herring, but it is currently the favoured
way to pass non-type-checked arguments to library macros which vala is
wrapping as functions - maybe some work could be done on "void" here, or
"any" [like python] for un-type-checked arguments)

This function is useful when a macro wants the C type passing, generally
for stringifying or casting; I particularly need it to make use of this
Samba4 talloc library macro, which is a pretty darn useful macro, wrapped
with this vapi:
      [CCode (sentinel="")]
      public void* zero(void* mem_ctx, ...);

NOTE: only one of the fragment for
  gobject/valaccodeinvocationexpressionbinding.vala
and
  gobject/valaccodegenerator.vala
is needed.

valaccodeinvocationexpressionbinding has the most specific patch only
covering the ellipses case in method invocation generation,
valaccodegenerator has a more general case and triggers quite often and
so for all I know has some broader side effects.

Perhaps the valaccodegenerator.vala patch should check that the parent
symbol is an argument

We shortly already talked about this on IRC some time ago. I still don't like the idea to abuse typeof for that. We're in the process of making varargs typesafe, we don't want to introduce even more issues.

Is there no other solution for the issue you're facing? Can you describe how exactly you're using these talloc functions? Using generics might be a lot better for this use case.

I don't think this conflicts with the idea of varargs being typesafe at all.

I'm just asking that vala be able to emit the type symbol.

talloc uses the type symbol in 2 ways:
1. it calls sizeof() so it knows how much to allocate
2. it stringifies it for reporting, debug and run-time type checking

It is perfectly reasonable behaviour for a C api to use sizeof() in macros, we ought to support the emitting of type symbols

Sam

The proposed solution does not make sense from a language point of view. If you can find a solution that fits better to the language semantics (maybe using generics and/or CCode attributes), please reopen the bug.

As varargs is [to be] typesafe, perhaps we can use a notation in vapi definitions for arguments which expect the type symbol.

I'll contrast the method I was proposing with what is perhaps a more acceptable alternative. Please don't get distracted by the talloc api and whether or not that could be implemented in a better way, it's just an example of a C macro API that expects the type symbol as an argument.

I had been using vapi:
      [CCode (sentinel="")]
      public void* zero(void* mem_ctx, ...);

and vala:
      a_compact_class cc = talloc.zero(parent, typeof(a_compact_class));

which emitted C something like:
      struct a_compact_class cc = talloc_zero(parent, struct a_compact_class);

however, as this abuses typeof from a language point of view (but IMHO not from a semantic point of view), how about vapi:

      [CCode (sentinel="")]
      public void* zero(void* mem_ctx, typesymbol type);

vala:
      a_compact_class cc = talloc.zero(parent, a_compact_class);

I don't prefer this method because in fact for the C macro, this is a typeless argument, and I can't see how this method will work for ellipses arguments - but it moves the magic to the declaration rather than the use, and this may be preferable from a language point of view.