import std;
auto abc(T)(auto ref T a, auto ref T b){
    return a+b;
}

auto def(T)(auto ref T a, auto ref T b){
        return a*b;

}
alias macro_1 = abc;
void main()
{
    writeln(macro_1(15, 20));
    alias macro_1 = def;// is this NOT considered variable shadowing?
    writeln(macro_1(100, 20));

}

On Saturday, 14 August 2021 at 03:47:05 UTC, Tejas wrote:

import std;
auto abc(T)(auto ref T a, auto ref T b){
    return a+b;
}

auto def(T)(auto ref T a, auto ref T b){
        return a*b;

}
alias macro_1 = abc;
void main()
{
    writeln(macro_1(15, 20));
    alias macro_1 = def;// is this NOT considered variable shadowing?
    writeln(macro_1(100, 20));

}

Shadowing local symbols is illegal. But it's okay for local symbols to have the same name as module-scope symbols. You can disambigbuate with the module scope operator:

void main()
   macro_1(); // the local symbol
   .macro_1(); // the external symbol
}

On Saturday, 14 August 2021 at 04:01:31 UTC, Mike Parker wrote:

import std;
auto abc(T)(auto ref T a, auto ref T b){
    return a+b;
}

auto def(T)(auto ref T a, auto ref T b){
        return a*b;

}
alias macro_1 = abc;
void main()
{
    writeln(macro_1(15, 20));
    alias macro_1 = def;// is this NOT considered variable shadowing?
    writeln(macro_1(100, 20));

}

void main()
   macro_1(); // the local symbol
   .macro_1(); // the external symbol
}

Oh right, the . operator will reference variable in the module scope, not just the immediate outer scope, that's why it is not considered shadowing in that case.

Thank you very much!

On Saturday, 14 August 2021 at 04:09:34 UTC, Tejas wrote:

you can use the module name to disambiguate as well. To extend Mike answer, the general rule is that if you can distinguish two names there's no shadowing.

On Saturday, 14 August 2021 at 08:23:20 UTC, user1234 wrote:

Understood