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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
|
# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
import sys
from io import TextIOWrapper
from typing import TYPE_CHECKING, Any, List, Optional, TextIO, Tuple, Union
from astroid import nodes
from pylint.constants import (
_SCOPE_EXEMPT,
MAIN_CHECKER_NAME,
MSG_STATE_CONFIDENCE,
MSG_STATE_SCOPE_CONFIG,
MSG_STATE_SCOPE_MODULE,
MSG_TYPES,
MSG_TYPES_LONG,
MSG_TYPES_STATUS,
WarningScope,
)
from pylint.exceptions import (
InvalidMessageError,
NoLineSuppliedError,
UnknownMessageError,
)
from pylint.interfaces import UNDEFINED, Confidence
from pylint.message.message import Message
from pylint.utils import get_module_and_frameid, get_rst_section, get_rst_title
if TYPE_CHECKING:
from pylint.lint.pylinter import PyLinter
from pylint.message import MessageDefinition
class MessagesHandlerMixIn:
"""A mix-in class containing all the messages related methods for the main lint class."""
__by_id_managed_msgs: List[Tuple[str, str, str, int, bool]] = []
def __init__(self):
self._msgs_state = {}
self.msg_status = 0
def _checker_messages(self, checker):
for known_checker in self._checkers[checker.lower()]:
yield from known_checker.msgs
@classmethod
def clear_by_id_managed_msgs(cls):
cls.__by_id_managed_msgs.clear()
@classmethod
def get_by_id_managed_msgs(cls):
return cls.__by_id_managed_msgs
def _register_by_id_managed_msg(self, msgid_or_symbol: str, line, is_disabled=True):
"""If the msgid is a numeric one, then register it to inform the user
it could furnish instead a symbolic msgid."""
if msgid_or_symbol[1:].isdigit():
try:
symbol = self.msgs_store.message_id_store.get_symbol(msgid=msgid_or_symbol) # type: ignore
except UnknownMessageError:
return
managed = (self.current_name, msgid_or_symbol, symbol, line, is_disabled) # type: ignore
MessagesHandlerMixIn.__by_id_managed_msgs.append(managed)
def disable(self, msgid, scope="package", line=None, ignore_unknown=False):
self._set_msg_status(
msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown
)
self._register_by_id_managed_msg(msgid, line)
def disable_next(
self,
msgid: str,
scope: str = "package",
line: Union[bool, int, None] = None,
ignore_unknown: bool = False,
):
if not line:
raise NoLineSuppliedError
self._set_msg_status(
msgid,
enable=False,
scope=scope,
line=line + 1,
ignore_unknown=ignore_unknown,
)
self._register_by_id_managed_msg(msgid, line + 1)
def enable(self, msgid, scope="package", line=None, ignore_unknown=False):
self._set_msg_status(
msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown
)
self._register_by_id_managed_msg(msgid, line, is_disabled=False)
def _set_msg_status(
self, msgid, enable, scope="package", line=None, ignore_unknown=False
):
assert scope in ("package", "module")
if msgid == "all":
for _msgid in MSG_TYPES:
self._set_msg_status(_msgid, enable, scope, line, ignore_unknown)
return
# msgid is a category?
category_id = msgid.upper()
if category_id not in MSG_TYPES:
category_id = MSG_TYPES_LONG.get(category_id)
if category_id is not None:
for _msgid in self.msgs_store._msgs_by_category.get(category_id):
self._set_msg_status(_msgid, enable, scope, line)
return
# msgid is a checker name?
if msgid.lower() in self._checkers:
for checker in self._checkers[msgid.lower()]:
for _msgid in checker.msgs:
self._set_msg_status(_msgid, enable, scope, line)
return
# msgid is report id?
if msgid.lower().startswith("rp"):
if enable:
self.enable_report(msgid)
else:
self.disable_report(msgid)
return
try:
# msgid is a symbolic or numeric msgid.
message_definitions = self.msgs_store.get_message_definitions(msgid)
except UnknownMessageError:
if ignore_unknown:
return
raise
for message_definition in message_definitions:
self._set_one_msg_status(scope, message_definition, line, enable)
def _set_one_msg_status(self, scope, msg, line, enable):
if scope == "module":
self.file_state.set_msg_status(msg, line, enable)
if not enable and msg.symbol != "locally-disabled":
self.add_message(
"locally-disabled", line=line, args=(msg.symbol, msg.msgid)
)
else:
msgs = self._msgs_state
msgs[msg.msgid] = enable
# sync configuration object
self.config.enable = [
self._message_symbol(mid) for mid, val in sorted(msgs.items()) if val
]
self.config.disable = [
self._message_symbol(mid)
for mid, val in sorted(msgs.items())
if not val
]
def _message_symbol(self, msgid):
"""Get the message symbol of the given message id
Return the original message id if the message does not
exist.
"""
try:
return [md.symbol for md in self.msgs_store.get_message_definitions(msgid)]
except UnknownMessageError:
return msgid
def get_message_state_scope(self, msgid, line=None, confidence=UNDEFINED):
"""Returns the scope at which a message was enabled/disabled."""
if self.config.confidence and confidence.name not in self.config.confidence:
return MSG_STATE_CONFIDENCE
try:
if line in self.file_state._module_msgs_state[msgid]:
return MSG_STATE_SCOPE_MODULE
except (KeyError, TypeError):
return MSG_STATE_SCOPE_CONFIG
return None
def is_message_enabled(self, msg_descr, line=None, confidence=None):
"""return true if the message associated to the given message id is
enabled
msgid may be either a numeric or symbolic message id.
"""
if self.config.confidence and confidence:
if confidence.name not in self.config.confidence:
return False
try:
message_definitions = self.msgs_store.get_message_definitions(msg_descr)
msgids = [md.msgid for md in message_definitions]
except UnknownMessageError:
# The linter checks for messages that are not registered
# due to version mismatch, just treat them as message IDs
# for now.
msgids = [msg_descr]
for msgid in msgids:
if self.is_one_message_enabled(msgid, line):
return True
return False
def is_one_message_enabled(self, msgid, line):
if line is None:
return self._msgs_state.get(msgid, True)
try:
return self.file_state._module_msgs_state[msgid][line]
except KeyError:
# Check if the message's line is after the maximum line existing in ast tree.
# This line won't appear in the ast tree and won't be referred in
# self.file_state._module_msgs_state
# This happens for example with a commented line at the end of a module.
max_line_number = self.file_state.get_effective_max_line_number()
if max_line_number and line > max_line_number:
fallback = True
lines = self.file_state._raw_module_msgs_state.get(msgid, {})
# Doesn't consider scopes, as a disable can be in a different scope
# than that of the current line.
closest_lines = reversed(
[
(message_line, enable)
for message_line, enable in lines.items()
if message_line <= line
]
)
last_line, is_enabled = next(closest_lines, (None, None))
if last_line is not None:
fallback = is_enabled
return self._msgs_state.get(msgid, fallback)
return self._msgs_state.get(msgid, True)
def add_message( # type: ignore # MessagesHandlerMixIn is always mixed with PyLinter
self: "PyLinter",
msgid: str,
line: Optional[int] = None,
node: Optional[nodes.NodeNG] = None,
args: Any = None,
confidence: Optional[Confidence] = None,
col_offset: Optional[int] = None,
) -> None:
"""Adds a message given by ID or name.
If provided, the message string is expanded using args.
AST checkers must provide the node argument (but may optionally
provide line if the line number is different), raw and token checkers
must provide the line argument.
"""
if confidence is None:
confidence = UNDEFINED
message_definitions = self.msgs_store.get_message_definitions(msgid)
for message_definition in message_definitions:
self.add_one_message(
message_definition, line, node, args, confidence, col_offset
)
def add_ignored_message( # type: ignore # MessagesHandlerMixIn is always mixed with PyLinter
self: "PyLinter",
msgid: str,
line: int,
node: Optional[nodes.NodeNG] = None,
confidence: Optional[Confidence] = UNDEFINED,
) -> None:
"""Prepares a message to be added to the ignored message storage
Some checks return early in special cases and never reach add_message(),
even though they would normally issue a message.
This creates false positives for useless-suppression.
This function avoids this by adding those message to the ignored msgs attribute
"""
message_definitions = self.msgs_store.get_message_definitions(msgid)
for message_definition in message_definitions:
self.check_message_definition(message_definition, line, node)
self.file_state.handle_ignored_message(
self.get_message_state_scope(
message_definition.msgid, line, confidence
),
message_definition.msgid,
line,
)
@staticmethod
def check_message_definition(message_definition, line, node):
if message_definition.msgid[0] not in _SCOPE_EXEMPT:
# Fatal messages and reports are special, the node/scope distinction
# does not apply to them.
if message_definition.scope == WarningScope.LINE:
if line is None:
raise InvalidMessageError(
f"Message {message_definition.msgid} must provide line, got None"
)
if node is not None:
raise InvalidMessageError(
f"Message {message_definition.msgid} must only provide line, "
f"got line={line}, node={node}"
)
elif message_definition.scope == WarningScope.NODE:
# Node-based warnings may provide an override line.
if node is None:
raise InvalidMessageError(
f"Message {message_definition.msgid} must provide Node, got None"
)
def add_one_message( # type: ignore # MessagesHandlerMixIn is always mixed with PyLinter
self: "PyLinter",
message_definition: "MessageDefinition",
line: Optional[int],
node: Optional[nodes.NodeNG],
args: Any,
confidence: Optional[Confidence],
col_offset: Optional[int],
) -> None:
self.check_message_definition(message_definition, line, node)
if line is None and node is not None:
line = node.fromlineno
if col_offset is None and hasattr(node, "col_offset"):
col_offset = node.col_offset # type: ignore
# should this message be displayed
if not self.is_message_enabled(message_definition.msgid, line, confidence):
self.file_state.handle_ignored_message(
self.get_message_state_scope(
message_definition.msgid, line, confidence
),
message_definition.msgid,
line,
)
return
# update stats
msg_cat = MSG_TYPES[message_definition.msgid[0]]
self.msg_status |= MSG_TYPES_STATUS[message_definition.msgid[0]]
self.stats.increase_single_message_count(msg_cat, 1)
self.stats.increase_single_module_message_count(self.current_name, msg_cat, 1)
try:
self.stats.by_msg[message_definition.symbol] += 1
except KeyError:
self.stats.by_msg[message_definition.symbol] = 1
# Interpolate arguments into message string
msg = message_definition.msg
if args:
msg %= args
# get module and object
if node is None:
module, obj = self.current_name, ""
abspath = self.current_file
else:
module, obj = get_module_and_frameid(node)
abspath = node.root().file
if abspath is not None:
path = abspath.replace(self.reporter.path_strip_prefix, "", 1)
else:
path = "configuration"
# add the message
self.reporter.handle_message(
Message(
message_definition.msgid,
message_definition.symbol,
(abspath, path, module, obj, line or 1, col_offset or 0), # type: ignore
msg,
confidence,
)
)
def _get_checkers_infos(self):
by_checker = {}
for checker in self.get_checkers():
name = checker.name
if name != "master":
try:
by_checker[name]["checker"] = checker
by_checker[name]["options"] += checker.options_and_values()
by_checker[name]["msgs"].update(checker.msgs)
by_checker[name]["reports"] += checker.reports
except KeyError:
by_checker[name] = {
"checker": checker,
"options": list(checker.options_and_values()),
"msgs": dict(checker.msgs),
"reports": list(checker.reports),
}
return by_checker
def get_checkers_documentation(self):
result = get_rst_title("Pylint global options and switches", "-")
result += """
Pylint provides global options and switches.
"""
for checker in self.get_checkers():
name = checker.name
if name == MAIN_CHECKER_NAME:
if checker.options:
for section, options in checker.options_by_section():
if section is None:
title = "General options"
else:
title = f"{section.capitalize()} options"
result += get_rst_title(title, "~")
result += f"{get_rst_section(None, options)}\n"
result += get_rst_title("Pylint checkers' options and switches", "-")
result += """\
Pylint checkers can provide three set of features:
* options that control their execution,
* messages that they can raise,
* reports that they can generate.
Below is a list of all checkers and their features.
"""
by_checker = self._get_checkers_infos()
for checker in sorted(by_checker):
information = by_checker[checker]
checker = information["checker"]
del information["checker"]
result += checker.get_full_documentation(**information)
return result
def print_full_documentation(self, stream: TextIO = sys.stdout) -> None:
"""output a full documentation in ReST format"""
print(self.get_checkers_documentation()[:-1], file=stream)
@staticmethod
def _print_checker_doc(information, stream: TextIOWrapper) -> None:
"""Helper method used by doc/exts/pylint_extensions.py."""
checker = information["checker"]
del information["checker"]
print(checker.get_full_documentation(**information)[:-1], file=stream)
|