~widelands-dev/widelands/trunk

« back to all changes in this revision

Viewing changes to utils/check_clang_tidy_results.py

  • Committer: The Widelands Bunnybot
  • Date: 2023-05-17 14:36:43 UTC
  • Revision ID: bunnybot@widelands.org-20230517143643-5fkifnbedth02w0t
Disable ignored clang-tidy checks in the config file (#5917)

(by hessenfarmer)
06c0eb3fb0471f0f70d8d113b2ced9005b4d7c7b

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 
10
10
# Checks list: https://clang.llvm.org/extra/clang-tidy/checks/list.html
11
11
SUPPRESSED_CHECKS = {
 
12
    # These are also disabled in the project .clang-tidy config file
 
13
 
12
14
    # TODO(Nordfriese): Investigate which android-* and fuchsia-* checks we want to enable
13
15
    # (currently they're all excluded in the clang-tidy invokation)
14
16
 
15
17
    # Checks we strictly need and cannot clean up for the time being
16
 
    '[llvm-header-guard]',  # We have our own header style with a codecheck rule on it
17
 
    '[cert-dcl50-cpp]',  # We need this for our logger
18
 
    '[cppcoreguidelines-pro-type-vararg]',  # We need this for our logger
19
 
    '[hicpp-vararg]',
 
18
    'llvm-header-guard',  # We have our own header style with a codecheck rule on it
 
19
    'cert-dcl50-cpp',  # We need this for our logger
 
20
    'cppcoreguidelines-pro-type-vararg',  # We need this for our logger
 
21
    'hicpp-vararg',
20
22
 
21
23
    # Checks that probably do not make sense for us
22
24
    # (up for discussion; see https://github.com/widelands/widelands/discussions/5262)
23
 
    '[llvmlibc-callee-namespace]',
24
 
    '[modernize-use-trailing-return-type]',
25
 
    '[cppcoreguidelines-avoid-c-arrays]',
26
 
    '[hicpp-avoid-c-arrays]',
27
 
    '[modernize-avoid-c-arrays]',
28
 
    '[cppcoreguidelines-avoid-goto]',
29
 
    '[hicpp-avoid-goto]',
30
 
    '[cppcoreguidelines-no-malloc]',
31
 
    '[hicpp-no-malloc]',
32
 
    '[cppcoreguidelines-non-private-member-variables-in-classes]',
33
 
    '[misc-non-private-member-variables-in-classes]',
34
 
    '[cppcoreguidelines-owning-memory]',
35
 
    '[cppcoreguidelines-pro-bounds-array-to-pointer-decay]',
36
 
    '[hicpp-no-array-decay]',
37
 
    '[cppcoreguidelines-pro-bounds-constant-array-index]',
38
 
    '[cppcoreguidelines-pro-bounds-pointer-arithmetic]',
39
 
    '[cppcoreguidelines-pro-type-const-cast]',
40
 
    '[cppcoreguidelines-pro-type-reinterpret-cast]',
41
 
    '[cppcoreguidelines-pro-type-union-access]',
42
 
    '[google-default-arguments]',
43
 
    '[hicpp-uppercase-literal-suffix]',
44
 
    '[readability-uppercase-literal-suffix]',
45
 
    '[hicpp-use-auto]',
46
 
    '[modernize-use-auto]',
47
 
    '[modernize-raw-string-literal]',
48
 
    '[modernize-return-braced-init-list]',
49
 
    '[altera-id-dependent-backward-branch]',
50
 
    '[altera-unroll-loops]',
51
 
    '[llvmlibc-implementation-in-namespace]',
52
 
    '[llvmlibc-restrict-system-libc-headers]',
53
 
    '[misc-no-recursion]',
54
 
    '[modernize-replace-disallow-copy-and-assign-macro]',
55
 
    '[readability-identifier-length]',
 
25
    'llvmlibc-callee-namespace',
 
26
    'modernize-use-trailing-return-type',
 
27
    'cppcoreguidelines-avoid-c-arrays',
 
28
    'hicpp-avoid-c-arrays',
 
29
    'modernize-avoid-c-arrays',
 
30
    'cppcoreguidelines-avoid-goto',
 
31
    'hicpp-avoid-goto',
 
32
    'cppcoreguidelines-no-malloc',
 
33
    'hicpp-no-malloc',
 
34
    'cppcoreguidelines-non-private-member-variables-in-classes',
 
35
    'misc-non-private-member-variables-in-classes',
 
36
    'cppcoreguidelines-owning-memory',
 
37
    'cppcoreguidelines-pro-bounds-array-to-pointer-decay',
 
38
    'hicpp-no-array-decay',
 
39
    'cppcoreguidelines-pro-bounds-constant-array-index',
 
40
    'cppcoreguidelines-pro-bounds-pointer-arithmetic',
 
41
    'cppcoreguidelines-pro-type-const-cast',
 
42
    'cppcoreguidelines-pro-type-reinterpret-cast',
 
43
    'cppcoreguidelines-pro-type-union-access',
 
44
    'google-default-arguments',
 
45
    'hicpp-uppercase-literal-suffix',
 
46
    'readability-uppercase-literal-suffix',
 
47
    'hicpp-use-auto',
 
48
    'modernize-use-auto',
 
49
    'modernize-raw-string-literal',
 
50
    'modernize-return-braced-init-list',
 
51
    'altera-id-dependent-backward-branch',
 
52
    'altera-unroll-loops',
 
53
    'llvmlibc-implementation-in-namespace',
 
54
    'llvmlibc-restrict-system-libc-headers',
 
55
    'misc-no-recursion',
 
56
    'modernize-replace-disallow-copy-and-assign-macro',
 
57
    'readability-identifier-length',
 
58
    'boost-use-to-string',
56
59
 
57
60
    # Checks we probably want to clean up sometime (discussible; see link above)
58
 
    '[boost-use-to-string]',
59
 
    '[bugprone-exception-escape]',
60
 
    '[bugprone-macro-parentheses]',
61
 
    '[bugprone-narrowing-conversions]',
62
 
    '[bugprone-not-null-terminated-result]',
63
 
    '[bugprone-signed-char-misuse]',
64
 
    '[bugprone-too-small-loop-variable]',
65
 
    '[cert-err58-cpp]',
66
 
    '[cert-msc32-c]',
67
 
    '[cert-msc51-cpp]',
68
 
    '[clang-analyzer-core.CallAndMessage]',
69
 
    '[clang-analyzer-core.NonNullParamChecker]',
70
 
    '[clang-analyzer-core.UndefinedBinaryOperatorResult]',
71
 
    '[clang-analyzer-cplusplus.NewDelete]',
72
 
    '[clang-analyzer-cplusplus.NewDeleteLeaks]',
73
 
    '[clang-analyzer-optin.cplusplus.UninitializedObject]',
74
 
    '[clang-analyzer-optin.cplusplus.VirtualCall]',
75
 
    '[clang-diagnostic-documentation-unknown-command]',
76
 
    '[cppcoreguidelines-avoid-magic-numbers]',
77
 
    '[cppcoreguidelines-init-variables]',
78
 
    '[cppcoreguidelines-macro-usage]',
79
 
    '[cppcoreguidelines-narrowing-conversions]',
80
 
    '[cppcoreguidelines-pro-type-member-init]',
81
 
    '[cppcoreguidelines-slicing]',
82
 
    '[cppcoreguidelines-special-member-functions]',
83
 
    '[google-readability-function-size]',
84
 
    '[google-runtime-references]',
85
 
    '[hicpp-function-size]',
86
 
    '[hicpp-member-init]',
87
 
    '[hicpp-multiway-paths-covered]',
88
 
    '[hicpp-signed-bitwise]',
89
 
    '[hicpp-special-member-functions]',
90
 
    '[misc-macro-parentheses]',
91
 
    '[modernize-make-unique]',
92
 
    '[modernize-pass-by-value]',
93
 
    '[performance-unnecessary-value-param]',
94
 
    '[readability-const-return-type]',
95
 
    '[readability-convert-member-functions-to-static]',
96
 
    '[readability-function-size]',
97
 
    '[readability-magic-numbers]',
98
 
    '[altera-struct-pack-align]',
99
 
    '[bugprone-easily-swappable-parameters]',
100
 
    '[cert-err33-c]',
101
 
    '[concurrency-mt-unsafe]',
102
 
    '[cppcoreguidelines-avoid-non-const-global-variables]',
103
 
    '[cppcoreguidelines-prefer-member-initializer]',
104
 
    '[google-readability-casting]',
105
 
    '[hicpp-named-parameter]',
106
 
    '[readability-named-parameter]',
107
 
    '[modernize-use-default-member-init]',
108
 
    '[readability-function-cognitive-complexity]',
109
 
    '[readability-suspicious-call-argument]',
110
 
    '[performance-no-int-to-ptr]',
 
61
    'bugprone-exception-escape',
 
62
    'bugprone-macro-parentheses',
 
63
    'bugprone-narrowing-conversions',
 
64
    'bugprone-not-null-terminated-result',
 
65
    'bugprone-signed-char-misuse',
 
66
    'bugprone-too-small-loop-variable',
 
67
    'cert-err58-cpp',
 
68
    'cert-msc32-c',
 
69
    'cert-msc51-cpp',
 
70
    'clang-analyzer-core.CallAndMessage',
 
71
    'clang-analyzer-core.NonNullParamChecker',
 
72
    'clang-analyzer-cplusplus.NewDelete',
 
73
    'clang-analyzer-cplusplus.NewDeleteLeaks',
 
74
    'clang-analyzer-optin.cplusplus.UninitializedObject',
 
75
    'clang-analyzer-optin.cplusplus.VirtualCall',
 
76
    'clang-diagnostic-documentation-unknown-command',
 
77
    'cppcoreguidelines-avoid-magic-numbers',
 
78
    'cppcoreguidelines-init-variables',
 
79
    'cppcoreguidelines-macro-usage',
 
80
    'cppcoreguidelines-narrowing-conversions',
 
81
    'cppcoreguidelines-pro-type-member-init',
 
82
    'cppcoreguidelines-slicing',
 
83
    'cppcoreguidelines-special-member-functions',
 
84
    'google-readability-function-size',
 
85
    'google-runtime-references',
 
86
    'hicpp-function-size',
 
87
    'hicpp-member-init',
 
88
    'hicpp-multiway-paths-covered',
 
89
    'hicpp-signed-bitwise',
 
90
    'hicpp-special-member-functions',
 
91
    'misc-macro-parentheses',
 
92
    'modernize-make-unique',
 
93
    'modernize-pass-by-value',
 
94
    'performance-unnecessary-value-param',
 
95
    'readability-const-return-type',
 
96
    'readability-convert-member-functions-to-static',
 
97
    'readability-function-size',
 
98
    'readability-magic-numbers',
 
99
    'altera-struct-pack-align',
 
100
    'bugprone-easily-swappable-parameters',
 
101
    'cert-err33-c',
 
102
    'concurrency-mt-unsafe',
 
103
    'cppcoreguidelines-avoid-non-const-global-variables',
 
104
    'cppcoreguidelines-prefer-member-initializer',
 
105
    'google-readability-casting',
 
106
    'hicpp-named-parameter',
 
107
    'readability-named-parameter',
 
108
    'modernize-use-default-member-init',
 
109
    'readability-function-cognitive-complexity',
 
110
    'readability-suspicious-call-argument',
 
111
    'performance-no-int-to-ptr',
111
112
}
112
113
 
113
 
CHECK_REGEX = re.compile(r'.*\[([A-Za-z0-9.-]+)\]$')
 
114
CHECK_REGEX = re.compile(r'.*\[([A-Za-z0-9.,-]+)\]$')
114
115
 
115
116
 
116
117
def main():
138
139
        for line in contents:
139
140
            if line in errors:
140
141
                continue
141
 
            if 'third_party' in line or '/usr/include' in line:
142
 
                continue
143
 
            # We're not piloting alpha-level checks
144
 
            if 'clang-analyzer-alpha' in line:
145
 
                continue
146
 
            check_suppressed = False
147
 
            for check in SUPPRESSED_CHECKS:
148
 
                if check in line:
149
 
                    check_suppressed = True
 
142
            if 'src/third_party' in line or '/usr/include' in line:
 
143
                continue
 
144
            checks_match = CHECK_REGEX.match(line)
 
145
            if not checks_match:
 
146
                continue
 
147
            failed_checks = checks_match.group(1).split(',')
 
148
            for check in failed_checks:
 
149
                # We're not piloting alpha-level checks
 
150
                if 'clang-analyzer-alpha' in check:
 
151
                    continue
 
152
                if not check in SUPPRESSED_CHECKS:
 
153
                    print(line.strip())
 
154
                    errors.append(line)
150
155
                    break
151
 
            if not check_suppressed and CHECK_REGEX.match(line):
152
 
                print(line.strip())
153
 
                errors.append(line)
154
156
 
155
157
    if len(errors) > 0:
156
158
        print('########################################################')
157
159
        print('########################################################')
158
160
        print('###                                                  ###')
159
 
        print('###   Found %s error(s)                               ###'
 
161
        print('###   Found %5s error(s)                           ###'
160
162
              % len(errors))
161
163
        print('###                                                  ###')
162
164
        print('########################################################')