lintspec 0.12.2

A blazingly fast linter for NatSpec comments in Solidity code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// SPDX-License-Identifier: MIT
pragma solidity =0.8.19;

abstract contract AbstractBasic {
    function overriddenFunction() internal pure virtual returns (uint256 _returned);
}

contract BasicSample is AbstractBasic {
    /**
     * @notice Some notice of the struct
     */
    struct TestStruct {
        address someAddress;
        uint256 someNumber;
    }

    /// @notice An enum
    enum TestEnum {
        First,
        Second
    }

    /**
     * @notice Some error missing parameter natspec
     */
    error BasicSample_SomeError(uint256 _param1);

    /**
     * @notice An event missing parameter natspec
     */
    event BasicSample_BasicEvent(uint256 _param1);

    /**
     * @notice Empty string for revert checks
     * @dev result of doing keccak256(bytes(''))
     */
    bytes32 internal constant _EMPTY_STRING = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;

    /**
     * @notice A public state variable
     */
    uint256 public somePublicNumber;

    constructor(bool _randomFlag) {}

    /**
     * @notice External function that returns a bool
     * @dev A dev comment
     * @param  _magicNumber A parameter description
     * @param _name Another parameter description
     * @param _name Another parameter description
     * @return _isMagic Some return data
     */
    function externalSimple(uint256 _magicNumber, string memory _name) external pure returns (bool _isMagic) {
        return true;
    }

    /**
     * @notice Private test function
     * @param _magicNumber A parameter description
     */
    function privateSimple(uint256 _magicNumber) private pure {}

    /**
     * @notice Private test function
     *         with multiple
     * lines
     */
    function multiline() external pure {}

    /**
     * @notice Private test function
     * @notice Another notice
     */
    function multitag() external pure {}

    /**
     * @notice External function that returns a bool
     * @dev A dev comment
     * @param _magicNumber A parameter description
     * @param    _name Another parameter description
     * @return _isMagic Some return data
     * @return Test test
     */
    function externalSimpleMultipleReturn(uint256 _magicNumber, string memory _name)
        external
        pure
        returns (bool _isMagic, uint256)
    {
        return (true, 111);
    }

    /**
     * @notice External function that returns a bool
     * @dev A dev comment
     * @return Some return data
     */
    function externalSimpleMultipleUnnamedReturn() external pure returns (bool, uint256) {
        return (true, 111);
    }

    /**
     * @notice This function should have an inheritdoc tag
     */
    function overriddenFunction() internal pure override returns (uint256 _returned) {
        return 1;
    }

    function virtualFunction() public pure virtual returns (uint256 _returned) {}

    /**
     * @notice Modifier notice
     */
    modifier transferFee(uint256 _receiver) virtual {
        _;
    }

    /**
     * @dev This func must be ignored
     */
    receive() external payable {}

    /**
     * @dev This func must be ignored
     */
    fallback() external {}
}

contract ChildContract is BasicSample {
    constructor() BasicSample(true) {}

    /// @dev inheritdoc is missing
    /// @param _receiver the receiver
    modifier transferFee(uint256 _receiver) override {
        _;
    }
}