After translating some buggy C code (full of gotos and global variables) to D
and going hunting for bugs for some time, I have grown a desire to write this
post.
Variable name hiding is a source of bugs. A typical example:
int x;
void foo() {
int x = 5;
// lot of code code here
x++;
}
The local name 'x' hides the global variable name 'x'. Sometimes the programmer
thinks she is using a global variable, when instead she is using the local one,
of vice versa. Coding guidelines suggest to rename such local variable x to
avoid possible future troubles, and I agree with this advice.
Some ways to face this problem:
1) Do nothing.
2) Give optional explicit information about the source of all variable names
used in a function, using the optional @outer() I have proposed elsewhere.
3) Statically disallow (gives an error) local variables from shadowing global
ones.
4) Produce a warning when a local variable shadows a global ones, in a smart
way.
5) As the leading dot to denote global variables, require the use of another
leading symbol (or some other mean) to denote local variable, when there is
ambiguity.
--------------
Regarding option 1, in D global variables are uncommon if you follow modern
programming practices, and if you keep functions short it's easy to see if they
are shadowing an outer name.
But the situation is sometimes different if you are porting legacy C code to D,
or if you have bad D programmers :-)
--------------
Option 3 is not so bad, D language already contains some examples of this:
struct Foo { int j; }
void main() {
foreach (i; 0 .. 10)
foreach (i; 0 .. 10) {} // error
Foo f;
int j;
with (f) {
j++; // error
}
}
--------------
Option 4 too is not bad, especially if some care is given to avoid producing
warnings where they are not needed:
int x, y, z;
void main() {
int x;
.x++; // no warning, the scope is known
x++; // warning
string y;
y = "foo"; // no warning, .y y have incompatible types
int z;
float z;
z++; // warning, int is implicitly convertible to float
}
--------------
Option 5 means requiring explicit scope information when there there is a
collision:
int x;
void main() {
int x;
.x++; // no error, the scope is known
main.x++; // no error, the scope is known
}
--------------
I have discussed about hiding global variables from local ones, but D allows
nesting of functions, so this discussion applies to such variables too:
void main() {
int x;
void foo() {
int x;
// code here
x++;
}
}
Bye,
bearophile
