shadowing vs explicit naming

[amitu]

In 0.4 if a component argument is named x and component is foo, we use foo.x to refer to the component argument, and x on its own refers to global scope. This is done to avoid shadowing global variables.

This makes code more verbose, and we do not do this inside function body, which makes it inconsistent.

Should we pick explicit naming or allow shadowing?

[siddhantk232]

I'd personally prefer explicit naming. We keep the current behavior and make it consistent across the language (in function body).

Reason: It makes it apparent while reading the code where I should be looking for the variable definition.

[amitu]

What about local variables in functions?

-- void foo():
integer x: ;; function argument

integer y: ;;  local variable

{ 
    integer z: ;; block local variable
    foo.x + y + z  ;; ? or `foo.x + foo.y + foo.z`?
}

[amitu]

Even if we do later, we can not get rid of shadowing. Unless we try to create a rule saying block can create variable but namespace must be unique for the entire function.

Not allowing shadowing with a function seems a limiting feature, eg

integer x = 10;
integer x = foo(x);

[amitu]

We can also allow super::x (one level of super for every block nesting.

But so far we did not have :: syntax, so should it be super.x?