Question about alias and getOverloads

[uranuz]

Hello! I have a question about `alias` template parameter and 
getOverloads.
For instance I have some code like this:
// -----
import std;
import core.thread;

void foo(string param1) {}
void foo(string param1, int param2) {}

template Bar(alias Func)
{
     // Next line is not valid now. This is my understanding of 
how I wish it would work...
     pragma(msg, __traits(getOverloads, Func));
}

void main()
{
     Bar!foo;
}
//---
By the spec:
https://dlang.org/spec/traits.html#getOverloads
The signature of `getOverloads` trait requires me to pass a 
symbol where my function is contained (it could be class, struct 
or module). And a name of function that I want to get overloads 
for.

Let's imagine that `foo` overloads and Bar template are in 
different modules. And `Bar` template doesn't have no direct 
access to module where `foo` is contained. And `Bar` is 
instantiated outside module where `Bar` is declared.

I have two questions:
1. Whether `Bar` instantiation would get first, second or both 
overloads of function? Or maybe I would get two instantiations of 
template by the number of overloads? I don't understand well how 
this mechanic is working. Is it documented somewhere? Does 
actually one alias parameter represents only one symbol from 
overload set or all of them?

2. If alias parameter represents multiple symbols from overload 
set. Then I wish I could access to list of overloads having alias 
parameter. I wish to get count of overloads in my real case in 
order to issue an error that overloaded are not supported by my 
code.