Function overriding versus Solidity Compiler Warning: Function state mutability can be restricted to pure

Question

I have a function in a base contract that could have the state mutability modifier "pure" because it always returns true:

    BaseContract {
        function x(bytes memory) 
            public
            view
            returns(bool) 
        {
            return true
        }
    }

However, this function is usually overridden in derived contracts, like so:

DerivedContract is Base {
    function x (bytes memory payload) 
        public 
        view 
        returns(bool) 
    {
        // do some non-pure stuff
        // return true OR false
    }
}

My question regarding how to silence this compiler warning is rooted in deeper questions:

1. Does function overriding in Solidity still work, even if the to-be-overidden function has a non-identical state mutability modifier?
2. Therefore, can I change the state-mutability modifier of the base function to pure, and still have this function overridden, or will the two dissimilar state mutabilities (view vs. pure), all else being identical, result in some sort of function overloading?
3. If overriding a function with a dissimilar state mutability does not work, how can I silence the aforementioned compiler warning?

Thanks for your help!

Answer 1

I found that OpenZeppelin seems to silence such compiler warnings about state mutability in this way:

function _msgData() internal view returns (bytes memory) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
}

This snippet is from there Context.sol contract.

Answer 2

I believe that all of this can be solved with a single keyword - interface.

For example:

pragma solidity 0.4.26;

interface IBaseContract {
    function func(uint _x) external view returns (bool);
}

contract BaseContract is IBaseContract {
    function func(uint _x) external view returns (bool) {
        return _x == 1;
    }
}

contract DerivedContract is BaseContract {
    uint public x;
    function func(uint _x) external view returns (bool) {
        return _x == x;
    }
}

And the compilation warning is gone!

The only problem that I can think of here, is that you cannot declare public functions in an interface.

So for once, you cannot override your public variable getter functions, since those are... well, public.

But that can be solved by explicitly declaring an external getter function with a slightly different name (e.g., getVal instead of val).

Of course, you don't have to do this for every public variable in your contract, but just for those which are used by other contracts.

Second, if one of your functions must be public (because it is used both internally in the contract and externally by other contracts or from an off-chain script), then - again - you cannot delcare it in the interface.

The solution in this case is simply to split it into an external function and an internal or private function.

Note that with this approach, the only public function remaining in each contract would be the constructor itself, which can be either public or internal.