Local variable shadowing (CS0136)

[orthoxerox]

Why not allow us to declare a local variable with the same name as a local variable in an enclosing block? For example,

        public static void Main(string[] args)
        {
            var i = 1;
            {
                var i = i++;
                //i==1
                {
                    var i = "foo";
                    //i=="foo"
                }
                //i==1
            }
            //i==2
        }

would declare three separate variables. Perhaps they should be marked with an additional modifier to prevent accidental shadowing, like methods are?

        public static void Main(string[] args)
        {
            var i = 1;
            {
                new var i = i++;
                //i==1
                {
                    new var i = "foo";
                    //i=="foo"
                }
                //i==1
            }
            //i==2
        }

[HaloFour]

@orthoxerox Because it was decided during the design of C# 1.0 that said behavior is confusing and the cause of unexpected logic errors do to setting the wrong variable? I think it was a good idea then and you'll probably need a fantastic argument to demonstrate why the same potential problems don't still exist today.

[alrz]

As long as it's C# it's no good, for example in Rust it's rather useful (to change mutable binding to immutable etc) although you can make it a warning, still, shadow_unrelated is on by default, which is not currently applicable in C#, because we don't have such analysis and it just doesn't make sense as long as we don't have any ownership notation — for example in let foo = foo.uwrap(); the first variable becomes unusable. See #161 comment.

[ghost]

It would get complicated, mayge you could use some kind of keyword to go up a level, like the this keyboard when doing it with local vs instance variables?

public class Thing
{
    string Name;

    public Thing(string Name)
    {
        this.Name = Name;
    }
}

[HaloFour]

@dan2002s And have, what, a parameter to specify the number of levels "up" you want to go? That sounds unnecessarily complicated, all to avoid having to think of a different identifier.

[bondsbw]

I would prefer the exact opposite, that C# get rid of the ability to have overlapping names (such as using the same name for class member and a local variable or parameter). Unfortunately it would break BC to make that change now.

[Soulzityr]

I was assigned this ticket through codetriage. I believe that this should not be implemented. Can we close this issue as a won't fix?

[Pzixel]

With introduction of pattern matching this feature would be really great. I hate I have to write code like

var maybeSomething = foo?.Bar?.Baz;

if (maybeSomething is {} something1) { ... }
... // in multiple cases branches cannot be merged with single check
if (maybeSomething is {} something2) { ... }
...
if (maybeSomething is {} something3) { ... }
...

Is this resolution final? It seems like introducing variable shadowing shouldn't be a breaking change since it relaxes rules rather than the other way around.