eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

-:6d7bddfde5fe
+:c3cf24fe9113
 import ast
 import builtins
 import contextlib
 import copy
 import itertools
+import math
 import re
 import sys
 import tokenize
 from collections import defaultdict, namedtuple
+from dataclasses import dataclass
 from keyword import iskeyword
 from string import Formatter
 try:
 # Python 3.10+
 import AstUtilities
 from .eradicate import Eradicator
 from .MiscellaneousDefaults import MiscellaneousCheckerDefaultArgs
+BugbearMutableLiterals = ("Dict", "List", "Set")
+BugbearMutableComprehensions = ("ListComp", "DictComp", "SetComp")
+BugbearMutableCalls = (
+"Counter",
+"OrderedDict",
+"collections.Counter",
+"collections.OrderedDict",
+"collections.defaultdict",
+"collections.deque",
+"defaultdict",
+"deque",
+"dict",
+"list",
+"set",
+)
+BugbearImmutableCalls = (
+"tuple",
+"frozenset",
+"types.MappingProxyType",
+"MappingProxyType",
+"re.compile",
+"operator.attrgetter",
+"operator.itemgetter",
+"operator.methodcaller",
+"attrgetter",
+"itemgetter",
+"methodcaller",
+)
 def composeCallPath(node):
 """
 Generator function to assemble the call path of a given node.
 @ytype str
 """
 if isinstance(node, ast.Attribute):
 yield from composeCallPath(node.value)
 yield node.attr
+elif isinstance(node, ast.Call):
+yield from composeCallPath(node.func)
 elif isinstance(node, ast.Name):
 yield node.id
 class MiscellaneousChecker:
 "M501",
 "M502",
 "M503",
 "M504",
 "M505",
+"M506",
 "M507",
+"M508",
 "M509",
 "M510",
 "M511",
 "M512",
 "M513",
 "M533",
 "M534",
 "M535",
 "M536",
 "M537",
+"M539",
+"M540",
 ## Bugbear, opininonated
 "M569",
 ## Bugbear++
 "M581",
 "M582",
 "M711",
 ## print() statements
 "M801",
 ## one element tuple
 "M811",
-## Mutable Defaults
-"M821",
-"M822",
 ## return statements
 "M831",
 "M832",
 "M833",
 "M834",
 "M501",
 "M502",
 "M503",
 "M504",
 "M505",
+"M506",
 "M507",
+"M508",
 "M509",
 "M510",
 "M511",
 "M512",
 "M513",
 "M533",
 "M534",
 "M535",
 "M536",
 "M537",
+"M539",
+"M540",
 "M569",
 "M581",
 "M582",
 ),
 ),
 ),
 (self.__checkFuture, ("M701", "M702")),
 (self.__checkGettext, ("M711",)),
 (self.__checkPrintStatements, ("M801",)),
 (self.__checkTuple, ("M811",)),
-(self.__checkMutableDefault, ("M821", "M822")),
 (self.__checkReturn, ("M831", "M832", "M833", "M834")),
 (self.__checkLineContinuation, ("M841",)),
 (self.__checkImplicitStringConcat, ("M851", "M852")),
 (self.__checkExplicitStringConcat, ("M853",)),
 (self.__checkCommentedCode, ("M891",)),
 node.col_offset,
 "M200",
 compType[node.__class__],
 )
-def __checkMutableDefault(self):
-"""
-Private method to check for use of mutable types as default arguments.
-"""
-mutableTypes = (
-ast.Call,
-ast.Dict,
-ast.List,
-ast.Set,
-ast.DictComp,
-ast.ListComp,
-ast.SetComp,
-)
-mutableCalls = (
-"Counter",
-"OrderedDict",
-"collections.Counter",
-"collections.OrderedDict",
-"collections.defaultdict",
-"collections.deque",
-"defaultdict",
-"deque",
-"dict",
-"list",
-"set",
-)
-immutableCalls = (
-"tuple",
-"frozenset",
-"types.MappingProxyType",
-"MappingProxyType",
-"re.compile",
-"operator.attrgetter",
-"operator.itemgetter",
-"operator.methodcaller",
-"attrgetter",
-"itemgetter",
-"methodcaller",
-)
-functionDefs = [ast.FunctionDef]
-with contextlib.suppress(AttributeError):
-functionDefs.append(ast.AsyncFunctionDef)
-for node in ast.walk(self.__tree):
-if any(isinstance(node, functionDef) for functionDef in functionDefs):
-defaults = node.args.defaults[:]
-with contextlib.suppress(AttributeError):
-defaults += node.args.kw_defaults[:]
-for default in defaults:
-if any(
-isinstance(default, mutableType) for mutableType in mutableTypes
-):
-typeName = type(default).__name__
-if isinstance(default, ast.Call):
-callPath = ".".join(composeCallPath(default.func))
-if callPath in mutableCalls:
-self.__error(
-default.lineno - 1,
-default.col_offset,
-"M823",
-callPath + "()",
-)
-elif callPath not in immutableCalls:
-self.__error(
-default.lineno - 1,
-default.col_offset,
-"M822",
-typeName,
-)
-else:
-self.__error(
-default.lineno - 1, default.col_offset, "M821", typeName
-)
 def __dictShouldBeChecked(self, node):
 """
 Private function to test, if the node should be checked.
 @param node reference to the AST node
 #######################################################################
 ## BugBearVisitor
 ##
-## adapted from: flake8-bugbear v24.4.26
+## adapted from: flake8-bugbear v24.8.19
 ##
 ## Original: Copyright (c) 2016 Łukasz Langa
 #######################################################################
 BugBearContext = namedtuple("BugBearContext", ["node", "stack"])
+@dataclass
+class M540CaughtException:
+"""
+Class to hold the data for a caught exception.
+"""
+name : str
+hasNote: bool
 class BugBearVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor to check for various topics.
 self.violations = []
 self.contexts = []
 self.__M523Seen = set()
 self.__M505Imports = set()
+self.__M540CaughtException = None
 @property
 def nodeStack(self):
 """
 Public method to get a reference to the most recent node stack.
 return (
 re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", AstUtilities.getValue(arg))
 is not None
 )
-def __composeCallPath(self, node):
-"""
-Private method get the individual elements of the call path of a node.
-@param node reference to the node
-@type ast.Node
-@yield one element of the call path
-@ytype ast.Node
-"""
-if isinstance(node, ast.Attribute):
-yield from self.__composeCallPath(node.value)
-yield node.attr
-elif isinstance(node, ast.Call):
-yield from self.__composeCallPath(node.func)
-elif isinstance(node, ast.Name):
-yield node.id
 def toNameStr(self, node):
 """
 Public method to turn Name and Attribute nodes to strings, handling any
 depth of attribute accesses.
 @param node reference to the node to be processed
 @type ast.ExceptHandler
 """
 if node.type is None:
 # bare except is handled by pycodestyle already
-pass
+self.generic_visit(node)
+return
+oldM540CaughtException = self.__M540CaughtException
+if node.name is None:
+self.__M540CaughtException = None
 else:
-handlers = self.__flattenExcepthandler(node.type)
+self.__M540CaughtException = M540CaughtException(node.name, False)
-names = []
-badHandlers = []
+names = self.__checkForM513_M529_M530(node)
-ignoredHandlers = []
-for handler in handlers:
+if (
-if isinstance(handler, (ast.Name, ast.Attribute)):
+"BaseException" in names
-name = self.toNameStr(handler)
+and not ExceptBaseExceptionVisitor(node).reRaised()
-if name is None:
+):
-ignoredHandlers.append(handler)
+self.violations.append((node, "M536"))
-else:
-names.append(name)
-elif isinstance(handler, (ast.Call, ast.Starred)):
-ignoredHandlers.append(handler)
-else:
-badHandlers.append(handler)
-if badHandlers:
-self.violations.append((node, "M530"))
-if len(names) == 0 and not badHandlers and not ignoredHandlers:
-self.violations.append((node, "M529"))
-elif (
-len(names) == 1
-and not badHandlers
-and not ignoredHandlers
-and isinstance(node.type, ast.Tuple)
-):
-self.violations.append((node, "M513", *names))
-else:
-maybeError = self.__checkRedundantExcepthandlers(names, node)
-if maybeError is not None:
-self.violations.append(maybeError)
-if (
-"BaseException" in names
-and not ExceptBaseExceptionVisitor(node).reRaised()
-):
-self.violations.append((node, "M536"))
 self.generic_visit(node)
+if (
+self.__M540CaughtException is not None
+and self.__M540CaughtException.hasNote
+):
+self.violations.append((node, "M540"))
+self.__M540CaughtException = oldM540CaughtException
 def visit_UAdd(self, node):
 """
 Public method to handle unary additions.
 Public method to handle a function call.
 @param node reference to the node to be processed
 @type ast.Call
 """
+isM540AddNote = False
 if isinstance(node.func, ast.Attribute):
 self.__checkForM505(node)
+isM540AddNote = self.__checkForM540AddNote(node.func)
 else:
 with contextlib.suppress(AttributeError, IndexError):
 # bad super() call
 if isinstance(node.func, ast.Name) and node.func.id == "super":
 args = node.args
 self.__checkForM526(node)
 self.__checkForM528(node)
 self.__checkForM534(node)
+self.__checkForM539(node)
+# no need for copying, if used in nested calls it will be set to None
+currentM540CaughtException = self.__M540CaughtException
+if not isM540AddNote:
+self.__checkForM540Usage(node.args)
+self.__checkForM540Usage(node.keywords)
 self.generic_visit(node)
+if isM540AddNote:
+# Avoid nested calls within the parameter list using the variable itself.
+# e.g. `e.add_note(str(e))`
+self.__M540CaughtException = currentM540CaughtException
 def visit_Module(self, node):
 """
 Public method to handle a module node.
 @param node reference to the node to be processed
 Public method to handle assignments.
 @param node reference to the node to be processed
 @type ast.Assign
 """
+self.__checkForM540Usage(node.value)
 if len(node.targets) == 1:
 target = node.targets[0]
 if (
 isinstance(target, ast.Attribute)
 and isinstance(target.value, ast.Name)
 ):
 self.violations.append((node, "M511"))
 self.generic_visit(node)
+def visit_AsyncFunctionDef(self, node):
+"""
+Public method to handle async function definitions.
+@param node reference to the node to be processed
+@type ast.AsyncFunctionDef
+"""
+self.__checkForM506_M508(node)
+self.generic_visit(node)
 def visit_FunctionDef(self, node):
 """
 Public method to handle function definitions.
 @param node reference to the node to be processed
 @type ast.FunctionDef
 """
+self.__checkForM506_M508(node)
 self.__checkForM519(node)
 self.__checkForM521(node)
 self.generic_visit(node)
 @param node reference to the node to be processed
 @type ast.ClassDef
 """
 self.__checkForM521(node)
-self.__checkForM524AndM527(node)
+self.__checkForM524_M527(node)
 self.generic_visit(node)
 def visit_Try(self, node):
 """
 Public method to handle 'raise' statements.
 @param node reference to the node to be processed
 @type ast.Raise
 """
+if node.exc is None:
+self.__M540CaughtException = None
+else:
+self.__checkForM540Usage(node.exc)
+self.__checkForM540Usage(node.cause)
 self.__checkForM516(node)
 self.generic_visit(node)
 def visit_With(self, node):
 @param node reference to the node to be processed
 @type ast.AnnAssign
 """
 self.__checkForM532(node)
+self.__checkForM540Usage(node.value)
 self.generic_visit(node)
 def visit_Import(self, node):
 """
 for name in node.names:
 self.__M505Imports.add(name.asname or name.name)
 elif isinstance(node, ast.ImportFrom):
 for name in node.names:
 self.__M505Imports.add(f"{node.module}.{name.name or name.asname}")
-elif isinstance(node, ast.Call):
+elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
 if node.func.attr not in ("lstrip", "rstrip", "strip"):
 return  # method name doesn't match
 if (
 isinstance(node.func.value, ast.Name)
 if len(value) == len(set(value)):
 return  # no characters appear more than once
 self.violations.append((node, "M505"))
+def __checkForM506_M508(self, node):
+"""
+Private method to check the use of mutable literals, comprehensions and calls.
+@param node reference to the node to be processed
+@type ast.AsyncFunctionDef or ast.FunctionDef
+"""
+visitor = FunctionDefDefaultsVisitor("M506", "M508")
+visitor.visit(node.args.defaults + node.args.kw_defaults)
+self.violations.extend(visitor.errors)
 def __checkForM507(self, node):
 """
 Private method to check for unused loop variables.
 for child in ast.iter_child_nodes(node):
 _loop(child, badNodeTypes)
 for child in node.finalbody:
 _loop(child, (ast.Return, ast.Continue, ast.Break))
+def __checkForM513_M529_M530(self, node):
+"""
+Private method to check various exception handler situations.
+@param node reference to the node to be processed
+@type ast.ExceptHandler
+"""
+handlers = self.__flattenExcepthandler(node.type)
+names = []
+badHandlers = []
+ignoredHandlers = []
+for handler in handlers:
+if isinstance(handler, (ast.Name, ast.Attribute)):
+name = self.toNameStr(handler)
+if name is None:
+ignoredHandlers.append(handler)
+else:
+names.append(name)
+elif isinstance(handler, (ast.Call, ast.Starred)):
+ignoredHandlers.append(handler)
+else:
+badHandlers.append(handler)
+if badHandlers:
+self.violations.append((node, "M530"))
+if len(names) == 0 and not badHandlers and not ignoredHandlers:
+self.violations.append((node, "M529"))
+elif (
+len(names) == 1
+and not badHandlers
+and not ignoredHandlers
+and isinstance(node.type, ast.Tuple)
+):
+self.violations.append((node, "M513", *names))
+else:
+maybeError = self.__checkRedundantExcepthandlers(names, node)
+if maybeError is not None:
+self.violations.append(maybeError)
+return names
 def __checkForM515(self, node):
 """
 Private method to check for pointless comparisons.
 return
 # Preserve decorator order so we can get the lineno from the decorator node
 # rather than the function node (this location definition changes in Python 3.8)
 resolvedDecorators = (
-".".join(self.__composeCallPath(decorator))
+".".join(composeCallPath(decorator))
 for decorator in node.decorator_list
 )
 for idx, decorator in enumerate(resolvedDecorators):
 if decorator in {"classmethod", "staticmethod"}:
 return
 for err in sorted(suspiciousVariables):
 if reassignedInLoop.issuperset(err[2]):
 self.violations.append((err[3], "M523", err[2]))
-def __checkForM524AndM527(self, node):
+def __checkForM524_M527(self, node):
 """
 Private method to check for inheritance from abstract classes in abc and lack of
 any methods decorated with abstract*.
 @param node reference to the node to be processed
 """
 seen = []
 for handler in node.handlers:
 if isinstance(handler.type, (ast.Name, ast.Attribute)):
-name = ".".join(self.__composeCallPath(handler.type))
+name = ".".join(composeCallPath(handler.type))
 seen.append(name)
 elif isinstance(handler.type, ast.Tuple):
 # to avoid checking the same as M514, remove duplicates per except
 uniques = set()
 for entry in handler.type.elts:
-name = ".".join(self.__composeCallPath(entry))
+name = ".".join(composeCallPath(entry))
 uniques.add(name)
 seen.extend(uniques)
 # sort to have a deterministic output
 duplicates = sorted({x for x in seen if seen.count(x) > 1})
 @param node reference to the node to be processed
 @type ast.Call
 """
 if not isinstance(node.func, ast.Attribute):
 return
-if not isinstance(node.func.value, ast.Name) or node.func.value.id != "re":
+func = node.func
+if not isinstance(func.value, ast.Name) or func.value.id != "re":
 return
 def check(numArgs, paramName):
 if len(node.args) > numArgs:
-self.violations.append((node, "M534", node.func.attr, paramName))
+arg = node.args[numArgs]
+self.violations.append((arg, "M534", func.attr, paramName))
-if node.func.attr in ("sub", "subn"):
+if func.attr in ("sub", "subn"):
 check(3, "count")
-elif node.func.attr == "split":
+elif func.attr == "split":
 check(2, "maxsplit")
 def __checkForM535(self, node):
 """
 Private method to check that a static key isn't used in a dict comprehension.
 self.violations.append((node, "M535", node.key.value))
 elif isinstance(
 node.key, ast.Name
 ) and node.key.id not in self.__getDictCompLoopAndNamedExprVarNames(node):
 self.violations.append((node, "M535", node.key.id))
+def __checkForM539(self, node):
+"""
+Private method to check for correct ContextVar usage.
+@param node reference to the node to be processed
+@type ast.Call
+"""
+if not (
+(isinstance(node.func, ast.Name) and node.func.id == "ContextVar")
+or (
+isinstance(node.func, ast.Attribute)
+and node.func.attr == "ContextVar"
+and isinstance(node.func.value, ast.Name)
+and node.func.value.id == "contextvars"
+)
+):
+return
+# ContextVar only takes one kw currently, but better safe than sorry
+for kw in node.keywords:
+if kw.arg == "default":
+break
+else:
+return
+visitor = FunctionDefDefaultsVisitor("M539", "M539")
+visitor.visit(kw.value)
+self.violations.extend(visitor.errors)
+def __checkForM540AddNote(self, node):
+"""
+Private method to check add_note usage.
+@param node reference to the node to be processed
+@type ast.Attribute
+@return flag
+@rtype bool
+"""
+if (
+node.attr == "add_note"
+and isinstance(node.value, ast.Name)
+and self.__M540CaughtException
+and node.value.id == self.__M540CaughtException.name
+):
+self.__M540CaughtException.hasNote = True
+return True
+return False
+def __checkForM540Usage(self, node):
+"""
+Private method to check the usage of exceptions with added note.
+@param node reference to the node to be processed
+@type ast.expr or None
+"""
+def superwalk(node: ast.AST | list[ast.AST]):
+"""
+Function to walk an AST node or a list of AST nodes.
+@param node reference to the node or a list of nodes to be processed
+@type ast.AST or list[ast.AST]
+@yield next node to be processed
+@ytype ast.AST
+"""
+if isinstance(node, list):
+for n in node:
+yield from ast.walk(n)
+else:
+yield from ast.walk(node)
+if not self.__M540CaughtException or node is None:
+return
+for n in superwalk(node):
+if isinstance(n, ast.Name) and n.id == self.__M540CaughtException.name:
+self.__M540CaughtException = None
+break
 def __checkForM569(self, node):
 """
 Private method to check for changes to a loop's mutable iterable.
 @return dictionary containing the names as keys and the list of nodes
 @rtype dict
 """
 return self.__names
+class FunctionDefDefaultsVisitor(ast.NodeVisitor):
+"""
+Class used by M506, M508 and M539.
+"""
+def __init__(
+self,
+errorCodeCalls,  # M506 or M539
+errorCodeLiterals,  # M508 or M539
+):
+"""
+Constructor
+@param errorCodeCalls error code for ast.Call nodes
+@type str
+@param errorCodeLiterals error code for literal nodes
+@type str
+"""
+self.__errorCodeCalls = errorCodeCalls
+self.__errorCodeLiterals = errorCodeLiterals
+for nodeType in BugbearMutableLiterals + BugbearMutableComprehensions:
+setattr(
+self, f"visit_{nodeType}", self.__visitMutableLiteralOrComprehension
+)
+self.errors = []
+self.__argDepth = 0
+super().__init__()
+def __visitMutableLiteralOrComprehension(self, node):
+"""
+Private method to flag mutable literals and comprehensions.
+@param node AST node to be processed
+@type ast.Dict, ast.List, ast.Set, ast.ListComp, ast.DictComp or ast.SetComp
+"""
+# Flag M506 if mutable literal/comprehension is not nested.
+# We only flag these at the top level of the expression as we
+# cannot easily guarantee that nested mutable structures are not
+# made immutable by outer operations, so we prefer no false positives.
+# e.g.
+# >>> def this_is_fine(a=frozenset({"a", "b", "c"})): ...
+#
+# >>> def this_is_not_fine_but_hard_to_detect(a=(lambda x: x)([1, 2, 3]))
+#
+# We do still search for cases of B008 within mutable structures though.
+if self.__argDepth == 1:
+self.errors.append((node, self.__errorCodeCalls))
+# Check for nested functions.
+self.generic_visit(node)
+def visit_Call(self, node):
+"""
+Public method to process Call nodes.
+@param node AST node to be processed
+@type ast.Call
+"""
+callPath = ".".join(composeCallPath(node.func))
+if callPath in BugbearMutableCalls:
+self.errors.append((node, self.__errorCodeCalls))
+self.generic_visit(node)
+return
+if callPath in BugbearImmutableCalls:
+self.generic_visit(node)
+return
+# Check if function call is actually a float infinity/NaN literal
+if callPath == "float" and len(node.args) == 1:
+try:
+value = float(ast.literal_eval(node.args[0]))
+except Exception:
+pass
+else:
+if math.isfinite(value):
+self.errors.append((node, self.__errorCodeLiterals))
+else:
+self.errors.append((node, self.__errorCodeLiterals))
+# Check for nested functions.
+self.generic_visit(node)
+def visit_Lambda(self, node):
+"""
+Public method to process Lambda nodes.
+@param node AST node to be processed
+@type ast.Lambda
+"""
+# Don't recurse into lambda expressions
+# as they are evaluated at call time.
+pass
+def visit(self, node):
+"""
+Public method to traverse an AST node or a list of AST nodes.
+This is an extended method that can also handle a list of AST nodes.
+@param node AST node or list of AST nodes to be processed
+@type ast.AST or list of ast.AST
+"""
+self.__argDepth += 1
+if isinstance(node, list):
+for elem in node:
+if elem is not None:
+super().visit(elem)
+else:
+super().visit(node)
+self.__argDepth -= 1
 class M520NameFinder(NameFinder):
 """
 Class to extract a name out of a tree of nodes ignoring names defined within the

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py