Page History

Reuse of identifier names in subscopes leads to obscuration or shadowing, that is, the names . Reused identifiers in the current scope mask can render those defined elsewhere . This creates ambiguity especially when the original names need to be used and burdens code maintenanceinaccessible. Although the Java Language Specification (JLS) [JLS 2013] clearly resolves any syntactic ambiguity arising from obscuring or shadowing, such ambiguity burdens code maintainers and auditors, especially when code requires access to both the original named entity and the inaccessible one. The problem is aggravated exacerbated when the reused name is required to be defined in a different package.

Wiki MarkupAccording to the Java Language Specification \[[JLS 2005|AA. Java References#JLS 05]\] section 6.3.2 "Obscured Declarations":to §6.4.2, "Obscuring," of the JLS [JLS 2013],

A simple name may occur in contexts where it may potentially be interpreted as the name of a variable, a type, or a package. In these situations, the rules of §6.5 specify that a variable will be chosen in preference to a type, and that a type will be chosen in preference to a package.

This implies that a variable can obscure a type or a package, and a type can obscure a package name. Shadowing, on the other hand refers to masking of variables, fields, types, method parameters, labels and exception handler parameters in a subscope. Both these differ from hiding wherein , refers to one variable rendering another variable inaccessible in a containing scope. One type can also shadow another type.

No identifier should obscure or shadow another identifier in a containing scope. For example, a local variable should not reuse the name of a class field or method or a class name or package name. Similarly, an inner class name should not reuse the name of an outer class or package.

Both overriding and shadowing differ from hiding, in which an accessible member (typically non-privatenonprivate) that should have been inherited by a subclass is forgone in lieu of replaced by a locally declared subclass member that assumes the same name .

As a tenet, do not:

• Reuse the name of a superclass
• Reuse the name of an interface
• Reuse the name of a field defined in a superclass
• Reuse the name of a field that appears in the same method (in some different scope)
• Reuse the name of a field, type or another parameter across packages

but has a different, incompatible method signature.

Noncompliant Code Example (Field Shadowing)

...

This noncompliant code example implements a class that reuses the name of the class java.util.Vector. It attempts to introduce a different condition for the isEmpty() method for interfacing with native legacy code, by overriding the corresponding method in java.util.Vector.

A future programmer may not know about this extension and may incorrectly use the Vector idiom intending to use the original java.util.Vector class. The custom type Vector can obscure a package name (java.util.Vector). This can cause undesirable effects by violating the programmer's assumptions.

Well defined import statements do resolve these issues but may get confusing when the reused name is defined in a different package. Moreover, a common (and misleading) tendency is to include the import statements after writing the code (many IDEs allow automatic inclusion of import statements as per the requirements). This can create even more ambiguity with respect to the names because if a custom type is found in the same package, no further searches are conducted for the package names that must be importedval instance field in the scope of an instance method.

Code Block
bgColor #FFcccc
class VectorMyVector { private int val = 1; publicprivate booleanvoid isEmptydoLogic() { if(val == 1) { //compares with 1 instead of 0 return trueint val; } else { return false; } } //other functionality is same as java.util.Vector } // import java.util.Vector; omitted public class VectorUser { public static void main(String[] args) { Vector v = new Vector(); if(v.isEmpty()) { System.out.println("Vector is empty"); } } }

Compliant Solution

This compliant solution declares the class Vector with a different name.

class MyVector {
  //other code
}

Noncompliant Code Example

This noncompliant code example reuses the name of the val instance field in the scope of an instance method. This behavior can be classified as shadowing.

//...   
  }
}

The resulting behavior can be classified as shadowing; the method variable renders the instance variable inaccessible within the scope of the method. For example, assigning to val from within the method does not affect the value of the instance variable, although assigning to this.val from within the method does.

Compliant Solution (Field Shadowing)

This compliant solution eliminates shadowing by changing the name of the variable defined in the method scope from val to newValue:

class MyVector

class Vector {
  private int val = 1;
  private void doLogic() {
    int valnewValue;
    //...   
  }
}

Compliant Solution

This solution eliminates shadowing by using a different name for the variable defined in method scope.

private void doLogic() {
  int newValue;
  //...   
}

Noncompliant Code Example

Noncompliant Code Example (Variable Shadowing)

This example is noncompliant because the variable i defined in the scope of the second for loop block shadows the definition of the instance variable i defined in the MyVector class:Method shadowing in different scopes becomes possible when two or more packages are used. Method shadowing is distinct from method overloading in that, subclasses are allowed to inherit overloadings defined in the base class. It differs from hiding in that the methods do not have to be declared static. It is also distinct from method overriding as exemplified in this noncompliant code example.

package x;
public class AMyVector {
  voidprivate doLogic()int {i // default accessibility= 0;
    // print 'A'  
  }  
  public static void main(String[] argsprivate void doLogic() {
    Afor a(i = new y.C();
    a.doLogic(); // invokes doLogic() of class x.B and prints 'B'
  }
}

package x;
public class B extends A {
  void doLogic() { // default accessibility
    // print 'B'  
  } 
}

package y; // different package
public class C extends x.B { // public accessibility 
  public void doLogic() { 
    // print 'C'
  } 
}

Note that class y.C is accessible from the package x and so is its doLogic() method. However, if the main() method defined in class A tries to polymorphically invoke y.doLogic() as shown, the override corresponding to class B in package x takes precedence. This is because the doLogic() methods in classes x.A and x.B are not visible from class y.C due to the default access specifier. As a result, the class x.C is not considered a part of the overriding hierarchy. Notably, the code behaves as expected if the access specifiers of all the methods are changed to public.

Compliant Solution

0; i < 10; i++) {/* ... */}
    for (int i = 0; i < 20; i++) {/* ... */} 
  }
}

Compliant Solution (Variable Shadowing)

In this compliant solution, the loop counter i is defined in the scope of each for loop block:It is highly recommended that a different name be used so that it is clear that the class residing in another package is not meant to be a part of the overriding chain. A programmer can proceed to invoke methods on it by explicitly using the class name. Even when all the classes define methods with a public access specifier, it is better to avoid reusing names because an evolving class can limit method accessibility anytime in the future causing unexpected results.

package x;
public class AMyVector {
  private void doLogic() { 
    // print 'A'  
  }  

  public static void main(String[] args) {
    // explicitly invokes doSequence() of class y.C and prints 'C'
    y.C.doSequence(); 
  }
}

package x;
public class B { for (int i = 0; i < 10; i++) {/* ... */ }

package y; // different package
public class C extends x.B {  
  public void doSequence() { // now renamed
    // print 'C' 
  } 
}

Exceptions

EX1: Reuse of names is permitted for trivial loop counter declarations in the same scope:

for for (int i = 0; i < 1020; i++) {/* ... */} 
for(int i = 0; i < 20; i++) {  }
}

Risk Assessment

Applicability

Name reuse makes code more difficult Reusing names leads to code that is harder to read and maintain and may , which can result in security weaknesses. An automated tool can easily detect reuse of identifiers in containing scopes.

...

Automated Detection

Automated Detection

TODO

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

Other Languages

This rule appears in the C Secure Coding Standard as DCL01-C. Do not reuse variable names in subscopes.

This rule appears in the C++ Secure Coding Standard as DCL01-CPP. Do not reuse variable names in subscopes.

References

\[[JLS 2005|AA. Java References#JLS 05]\] 6.3.2 "Obscured Declarations", 6.3.1 "Shadowing Declarations", 14.4.3 "Shadowing of Names by Local Variables"
\[[Bloch 2008|AA. Java References#Bloch 08]\] Puzzle 67: All Strung Out
\[[Kabanov 2009|AA. Java References#Kabanov 09]\]
\[[Conventions 2009|AA. Java References#Conventions 09]\] 6.3 Placement
\[[FindBugs 2008|AA. Java References#FindBugs 08]\]:
Nm: Class names shouldn't shadow simple name of implemented interface  
Nm: Class names shouldn't shadow simple name of superclass
MF: Class defines field that masks a superclass field
MF: Method defines a variable that obscures a field

Bibliography

...

Image Added Image Added Image AddedSCP01-J. Do not increase the accessibility of overridden or hidden methods      05. Scope (SCP)      SCP03-J. Do not expose sensitive private members of the outer class from within a nested class