Define rules for writing custom getters for public functions

[chaoliu92]

As I understand, every public state variable will have a corresponding external getter function with the same name (but can have necessary input parameters for some cases).

My question is what if I have a function with the same signature (function name and input parameter types) as this auto-generated getter function?

I've experimented with the following simple contract in Remix, and I found the explicitly defined function (here number()) seems to shadow the auto-generated getter function.

pragma solidity ^0.4.21;

contract TestFunctionStateVariableNameConflict {
    event log(uint256 number);
    uint256 public number = 111;
    function number() public pure returns(uint256) {
        return 222;
    }
    function print() public {
        emit log(number);  // This will output value 111 (as the state variable)
        emit log(this.number());  // This will output value 222 (as the function number())
    }
}

Here I found the log output of function print() are 111 and 222. If I change the signature of function number() (e.g., add an unused input parameter bool unusend), the result will be both 111 as I expected, since the getter and explicitly defined function now have different signatures.

What's more, if I move the declaration of uint256 number to the end of the contract body (so it is after the declaration of function number()), I will be given a TypeError for emit log(number) and a DeclarationError for emit log(this.number());. It seems when dealing with emit log(number);, Solidity thinks here number is a function and so give a TypeError; and when seen uint256 public number = 111;, it thinks there's already an attribute named number (the function) and so give a DeclarationError.

pragma solidity ^0.4.21;

contract TestFunctionStateVariableNameConflict {
    event log(uint256 number);
    // uint256 public number = 111;
    function number() public pure returns(uint256) {
        return 222;
    }
    function print() public {
        emit log(number);  // This will lead to a TypeError
        emit log(this.number());
    }
    uint256 public number = 111;  // This will lead to a DeclarationError
}

So, my question is: should there be constraints between state variable names and function names in Solidity, especially when public state variables have their auto-generated getter functions? If so, what is the precise rule and where can I find it in any documentation.

[chriseth]

We are currently working on a proper inheritance and shadowing specification: #3698

[chriseth]

Sorry, the correct issue is #3729

[github-actions]

Hi everyone! This issue has been closed due to inactivity.
If you think this issue is still relevant in the latest Solidity version and you have something to contribute, feel free to reopen.
However, unless the issue is a concrete proposal that can be implemented, we recommend starting a language discussion on the forum instead.