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

-:094ab8028423
+:fa7b8ebfbe13
 "M531",
 "M532",
 "M533",
 "M534",
 "M535",
+"M536",
+"M537",
+"M538",
 ## Bugbear++
 "M581",
 "M582",
 ## Format Strings
 "M601",
 "M531",
 "M532",
 "M533",
 "M534",
 "M535",
+"M536",
+"M537",
+"M538",
 "M581",
 "M582",
 ),
 ),
 (self.__checkPep3101, ("M601",)),
 #######################################################################
 ## BugBearVisitor
 ##
-## adapted from: flake8-bugbear v23.11.26
+## adapted from: flake8-bugbear v24.1.17
 ##
 ## Original: Copyright (c) 2016 Łukasz Langa
 #######################################################################
 BugBearContext = namedtuple("BugBearContext", ["node", "stack"])
 elif isinstance(node, ast.Call):
 yield from self.__composeCallPath(node.func)
 elif isinstance(node, ast.Name):
 yield node.id
-def __toNameStr(self, node):
+def toNameStr(self, node):
 """
-Private method to turn Name and Attribute nodes to strings, handling any
+Public method to turn Name and Attribute nodes to strings, handling any
 depth of attribute accesses.
 @param node reference to the node
 @type ast.Name or ast.Attribute
 """
 if isinstance(node, ast.Name):
 return node.id
 if isinstance(node, ast.Call):
-return self.__toNameStr(node.func)
+return self.toNameStr(node.func)
 try:
-return self.__toNameStr(node.value) + "." + node.attr
+return self.toNameStr(node.value) + "." + node.attr
 except AttributeError:
-return self.__toNameStr(node.value)
+return self.toNameStr(node.value)
 def __typesafeIssubclass(self, obj, classOrTuple):
 """
 Private method implementing a type safe issubclass() function.
 if isinstance(dim, ast.Name):
 yield dim.id
 elif isinstance(dim, ast.Tuple):
 yield from self.__getNamesFromTuple(dim)
-def __getDictCompLoopVarNames(self, node):
+def __getDictCompLoopAndNamedExprVarNames(self, node):
 """
 Private method to get the names of comprehension loop variables.
 @param node ast node to be processed
 @type ast.DictComp
 @yield loop variable names
 @ytype str
 """
+finder = NamedExprFinder()
 for gen in node.generators:
 if isinstance(gen.target, ast.Name):
 yield gen.target.id
 elif isinstance(gen.target, ast.Tuple):
 yield from self.__getNamesFromTuple(gen.target)
+finder.visit(gen.ifs)
+yield from finder.getNames().keys()
+def __inClassInit(self):
+"""
+Private method to check, if we are inside an '__init__' method.
+@return flag indicating being within the '__init__' method
+@rtype bool
+"""
+return (
+len(self.contexts) >= 2
+and isinstance(self.contexts[-2].node, ast.ClassDef)
+and isinstance(self.contexts[-1].node, ast.FunctionDef)
+and self.contexts[-1].node.name == "__init__"
+)
+def visit_Return(self, node):
+"""
+Public method to handle 'Return' nodes.
+@param node reference to the node to be processed
+@type ast.Return
+"""
+if self.__inClassInit() and node.value is not None:
+self.violations.append((node, "M537"))
+self.generic_visit(node)
+def visit_Yield(self, node):
+"""
+Public method to handle 'Yield' nodes.
+@param node reference to the node to be processed
+@type ast.Yield
+"""
+if self.__inClassInit():
+self.violations.append((node, "M537"))
+self.generic_visit(node)
+def visit_YieldFrom(self, node) -> None:
+"""
+Public method to handle 'YieldFrom' nodes.
+@param node reference to the node to be processed
+@type ast.YieldFrom
+"""
+if self.__inClassInit():
+self.violations.append((node, "M537"))
+self.generic_visit(node)
 def visit(self, node):
 """
 Public method to traverse a given AST node.
 @param node AST node to be traversed
 self.nodeStack.pop()
 if isContextful:
 self.contexts.pop()
+self.__checkForM518(node)
 def visit_ExceptHandler(self, node):
 """
 Public method to handle exception handlers.
 names = []
 badHandlers = []
 ignoredHandlers = []
 for handler in handlers:
 if isinstance(handler, (ast.Name, ast.Attribute)):
-name = self.__toNameStr(handler)
+name = self.toNameStr(handler)
 if name is None:
 ignoredHandlers.append(handler)
 else:
 names.append(name)
 elif isinstance(handler, (ast.Call, ast.Starred)):
 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)
 def visit_UAdd(self, node):
 """
 Public method to handle a module node.
 @param node reference to the node to be processed
 @type ast.Module
 """
-self.__checkForM518(node)
 self.generic_visit(node)
 def visit_Assign(self, node):
 """
 Public method to handle assignments.
 """
 self.__checkForM507(node)
 self.__checkForM520(node)
 self.__checkForM523(node)
 self.__checkForM531(node)
+self.__checkForM538(node)
 self.generic_visit(node)
 def visit_AsyncFor(self, node):
 """
 Public method to handle function definitions.
 @param node reference to the node to be processed
 @type ast.FunctionDef
 """
-self.__checkForM518(node)
 self.__checkForM519(node)
 self.__checkForM521(node)
 self.generic_visit(node)
 Public method to handle class definitions.
 @param node reference to the node to be processed
 @type ast.ClassDef
 """
-self.__checkForM518(node)
 self.__checkForM521(node)
 self.__checkForM524AndM527(node)
 self.generic_visit(node)
 itemContext.func.attr == "assertRaises"
 or (
 itemContext.func.attr == "raises"
 and isinstance(itemContext.func.value, ast.Name)
 and itemContext.func.value.id == "pytest"
-and "match" not in [kwd.arg for kwd in itemContext.keywords]
+and "match" not in (kwd.arg for kwd in itemContext.keywords)
 )
 )
 )
 or (
 isinstance(itemContext.func, ast.Name)
 and itemContext.func.id == "raises"
 and isinstance(itemContext.func.ctx, ast.Load)
 and "pytest.raises" in self.__M505Imports
-and "match" not in [kwd.arg for kwd in itemContext.keywords]
+and "match" not in (kwd.arg for kwd in itemContext.keywords)
 )
 )
 and len(itemContext.args) == 1
 and isinstance(itemContext.args[0], ast.Name)
-and itemContext.args[0].id == "Exception"
+and itemContext.args[0].id in ("Exception", "BaseException")
 and not item.optional_vars
 ):
 self.violations.append((node, "M517"))
 def __checkForM518(self, node):
 Private method to check for useless expressions.
 @param node reference to the node to be processed
 @type ast.FunctionDef
 """
-for subnode in node.body:
+if not isinstance(node, ast.Expr):
-if not isinstance(subnode, ast.Expr):
+return
-continue
+if isinstance(
-if isinstance(
+node.value,
-subnode.value,
+(ast.List, ast.Set, ast.Dict, ast.Tuple),
-(ast.List, ast.Set, ast.Dict),
+) or (
-) or (
+isinstance(node.value, ast.Constant)
-isinstance(subnode.value, ast.Constant)
+and (
-and (
+isinstance(
-isinstance(
+node.value.value,
-subnode.value.value,
+(int, float, complex, bytes, bool),
-(int, float, complex, bytes, bool),
-)
-or subnode.value.value is None
 )
-):
+or node.value.value is None
-self.violations.append((subnode, "M518"))
+)
+):
+self.violations.append((node, "M518", node.value.__class__.__name__))
 def __checkForM519(self, node):
 """
 Private method to check for use of 'functools.lru_cache' or 'functools.cache'.
 if node.func.attr in ("sub", "subn"):
 check(3, "count")
 elif node.func.attr == "split":
 check(2, "maxsplit")
-def __checkForM535(self, node: ast.DictComp):
+def __checkForM535(self, node):
 """
 Private method to check that a static key isn't used in a dict comprehension.
 Record a warning if a likely unchanging key is used - either a constant,
 or a variable that isn't coming from the generator expression.
 @param node reference to the node to be processed
 @type ast.DictComp
-"""
-"""Check that a static key isn't used in a dict comprehension.
-Emit a warning if a likely unchanging key is used - either a constant,
-or a variable that isn't coming from the generator expression.
 """
 if isinstance(node.key, ast.Constant):
 self.violations.append((node, "M535", node.key.value))
 elif isinstance(
 node.key, ast.Name
-) and node.key.id not in self.__getDictCompLoopVarNames(node):
+) and node.key.id not in self.__getDictCompLoopAndNamedExprVarNames(node):
 self.violations.append((node, "M535", node.key.id))
+def __checkForM538(self, node):
+"""
+Private method to check for changes to a loop's mutable iterable.
+@param node loop node to be checked
+@type ast.For
+"""
+if isinstance(node.iter, ast.Name):
+name = self.toNameStr(node.iter)
+elif isinstance(node.iter, ast.Attribute):
+name = self.toNameStr(node.iter)
+else:
+return
+checker = M538Checker(name, self)
+checker.visit(node.body)
+for mutation in checker.mutations:
+self.violations.append((mutation, "M538"))
+class M538Checker(ast.NodeVisitor):
+"""
+Class traversing a 'for' loop body to check for modifications to a loop's
+mutable iterable.
+"""
+# https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types
+MUTATING_FUNCTIONS = (
+"append",
+"sort",
+"reverse",
+"remove",
+"clear",
+"extend",
+"insert",
+"pop",
+"popitem",
+)
+def __init__(self, name, bugbear):
+"""
+Constructor
+@param name name of the iterator
+@type str
+@param bugbear reference to the bugbear visitor
+@type BugBearVisitor
+"""
+self.__name = name
+self.__bb = bugbear
+self.mutations = []
+def visit_Delete(self, node):
+"""
+Public method handling 'Delete' nodes.
+@param node reference to the node to be processed
+@type ast.Delete
+"""
+for target in node.targets:
+if isinstance(target, ast.Subscript):
+name = self.__bb.toNameStr(target.value)
+elif isinstance(target, (ast.Attribute, ast.Name)):
+name = self.__bb.toNameStr(target)
+else:
+name = ""  # fallback
+self.generic_visit(target)
+if name == self.__name:
+self.mutations.append(node)
+def visit_Call(self, node):
+"""
+Public method handling 'Call' nodes.
+@param node reference to the node to be processed
+@type ast.Call
+"""
+if isinstance(node.func, ast.Attribute):
+name = self.__bb.toNameStr(node.func.value)
+functionObject = name
+functionName = node.func.attr
+if (
+functionObject == self.__name
+and functionName in self.MUTATING_FUNCTIONS
+):
+self.mutations.append(node)
+self.generic_visit(node)
+def visit(self, node):
+"""
+Public method to inspect an ast node.
+Like super-visit but supports iteration over lists.
+@param node AST node to be traversed
+@type TYPE
+@return reference to the last processed node
+@rtype ast.Node
+"""
+if not isinstance(node, list):
+return super().visit(node)
+for elem in node:
+super().visit(elem)
+return node
+class ExceptBaseExceptionVisitor(ast.NodeVisitor):
+"""
+Class to determine, if a 'BaseException' is re-raised.
+"""
+def __init__(self, exceptNode):
+"""
+Constructor
+@param exceptNode exception node to be inspected
+@type ast.ExceptHandler
+"""
+super().__init__()
+self.__root = exceptNode
+self.__reRaised = False
+def reRaised(self) -> bool:
+"""
+Public method to check, if the exception is re-raised.
+@return flag indicating a re-raised exception
+@rtype bool
+"""
+self.visit(self.__root)
+return self.__reRaised
+def visit_Raise(self, node):
+"""
+Public method to handle 'Raise' nodes.
+If we find a corresponding `raise` or `raise e` where e was from
+`except BaseException as e:` then we mark re_raised as True and can
+stop scanning.
+@param node reference to the node to be processed
+@type ast.Raise
+"""
+if node.exc is None or (
+isinstance(node.exc, ast.Name) and node.exc.id == self.__root.name
+):
+self.__reRaised = True
+return
+super().generic_visit(node)
+def visit_ExceptHandler(self, node: ast.ExceptHandler):
+"""
+Public method to handle 'ExceptHandler' nodes.
+@param node reference to the node to be processed
+@type ast.ExceptHandler
+"""
+if node is not self.__root:
+return  # entered a nested except - stop searching
+super().generic_visit(node)
 class NameFinder(ast.NodeVisitor):
 """
 Class to extract a name out of a tree of nodes.
 for elem in node:
 super().visit(elem)
 return node
 else:
 return super().visit(node)
+def getNames(self):
+"""
+Public method to return the extracted names and Name nodes.
+@return dictionary containing the names as keys and the list of nodes
+@rtype dict
+"""
+return self.__names
+class NamedExprFinder(ast.NodeVisitor):
+"""
+Class to extract names defined through an ast.NamedExpr.
+"""
+def __init__(self):
+"""
+Constructor
+"""
+super().__init__()
+self.__names = {}
+def visit_NamedExpr(self, node: ast.NamedExpr):
+"""
+Public method handling 'NamedExpr' nodes.
+@param node reference to the node to be processed
+@type ast.NamedExpr
+"""
+self.__names.setdefault(node.target.id, []).append(node.target)
+self.generic_visit(node)
+def visit(self, node):
+"""
+Public method to traverse a given AST node.
+Like super-visit but supports iteration over lists.
+@param node AST node to be traversed
+@type TYPE
+@return reference to the last processed node
+@rtype ast.Node
+"""
+if not isinstance(node, list):
+super().visit(node)
+for elem in node:
+super().visit(elem)
+return node
 def getNames(self):
 """
 Public method to return the extracted names and Name nodes.

Mercurial Repositories > eric / file comparison

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

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