www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Fun determining the number of parameters using core reflect

reply Stefan Koch <uplink.coder googlemail.com> writes:
Hi there,

I've just been wanted to know if a particular local variable has 
is pointer taken inside a function.
i.e. whether it's aliased.

In order to reflect on that I would have to look at where it is 
defined i.e. reflect on the lexical parent which is possible but 
is currently disabled by default since it's expensive.

So I wondered if I could just get the parent function node inside 
my reflection function, which works since I can get the string of 
the function I am in.

After a bit of tinkering I arrived at the following code.

Enjoy!

And please feel free to ask questions and suggest improvements!

```
import core.reflect.reflect;
int f()
{
     int x;
     static assert(nParameters == 0);
     g(&x);
     return x;
}
int f2(int x, float y)
{
     static assert(nParameters == 2);
     return x;
}

void g(int* x) {}

 (core.reflect) uint nParameters(immutable string fName = 
__FUNCTION__, immutable Scope _scope = currentScope())
{
     auto F = cast(const FunctionDeclaration)
         nodeFromName(fName, ReflectFlags.NoParent | 
ReflectFlags.NoFunctionbody, _scope);
     uint params = cast(uint)F.type.parameterTypes.length;
     return params;
}
```
Sep 11
next sibling parent Stefan Koch <uplink.coder googlemail.com> writes:
On Saturday, 11 September 2021 at 08:48:34 UTC, Stefan Koch wrote:
 Hi there,
Ah one more think I forgot to mention. If you want to play with this be advised that my core_reflect branch is currently trying to be somewhat stable. The cutting edge changes you need for this example to work are in the. core_reflect_newCTFE branch.
Sep 11
prev sibling parent Stefan Koch <uplink.coder googlemail.com> writes:
On Saturday, 11 September 2021 at 08:48:34 UTC, Stefan Koch wrote:
 Hi there,

 ```
 import core.reflect.reflect;
  (core.reflect) uint nParameters(immutable string fName = 
 __FUNCTION__, immutable Scope _scope = currentScope())
 {
     auto F = cast(const FunctionDeclaration)
         nodeFromName(fName, ReflectFlags.NoParent | 
 ReflectFlags.NoFunctionbody, _scope);
     uint params = cast(uint)F.type.parameterTypes.length;
     return params;
 }
 ```
I can already hear you ask if that supports eponymous templates. The answers is ... yes it does. As of a few minutes ago :) ``` string nArgs(T...)(T args) { static assert(nParameters == 4, "template has to be called with 4 arguments excat> return "reflection is cool"; } pragma(msg, nArgs(1, 2, "trythis", 4.0)); // pragma(msg, nArgs(1, 2, "trythis", 4.0, 1)); // won't compile static assert fails ``` You can determine the type and names of the parameters passed in. You can determine how they are used in the function body if there is a body. I just realized a few minutes ago what interesting things allows you to do.
Sep 11