Solidity allows developers to ambiguously declare state variables. This means that even though two different variables in two different contexts can be declared with the same name, using them can lead to confusion and misuse.

This can happen both at the function level and at the inheritance level. For example, if Contract1 declares var1 and inherits from Contract2, which also declares a variable named var1, then the variable is ambiguous and can easily be confused with each other later in the smart contract execution.

Example 1: The following code uses inheritance and declares a state variable with the same name in both smart contracts. It can be hard to determine which is the actual hardcap of the token sale.

contract Tokensale {
    uint hardcap = 10000 ether;

    function Tokensale() { }

    function fetchCap() public constant returns(uint) {
        return hardcap;
    }
}

contract Presale is Tokensale {
    uint hardcap = 1000 ether;

    function Presale() Tokensale() { }
}

This variable's initial value is not used. After initialization, the variable is either assigned another value or goes out of scope.

Example: The following code excerpt assigns to the variable r and then overwrites the value without using it.

  int r = getNum();
  r = getNewNum(buf);

This variable's value is not used. After the assignment, the variable is either assigned another value or goes out of scope.

Example: The following code excerpt assigns to the variable r and then overwrites the value without using it.

  r = getName();
  r = getNewBuffer(buf);

Solidity permits variables to be declared and never used and although most of the time this does not directly point to a security vulnerability, it is a bad practice. It can cause noise and unnecessary gas consumption due to the required increased computation cycles.

Example 1: The following code declares the variable var1 of type A but never uses it.

contract Base {
    struct A { uint a; }
}

contract DerivedA is Base {
    A var1 = A(1);
    int internal j = 500;

    function call(int a) public {
        assign1(a);
    }

    function assign3(A memory x) public returns (uint) {
        return g[1] + x.a + uint(j);
    }
}