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

-:1d8eadd8873e
+:2b768afcaee1
 """
 Module implementing a checker for miscellaneous checks.
 """
+import ast
+import builtins
+import contextlib
+import copy
+import itertools
+import re
 import sys
-import ast
+import tokenize
-import re
+from collections import defaultdict, namedtuple
-import itertools
+from keyword import iskeyword
 from string import Formatter
-from collections import defaultdict
-import tokenize
-import copy
-import contextlib
 import AstUtilities
 from .eradicate import Eradicator
 "M501",
 "M502",
 "M503",
 "M504",
 "M505",
-"M506",
 "M507",
-"M508",
 "M509",
+"M510",
 "M511",
 "M512",
 "M513",
+"M514",
+"M515",
+"M516",
+"M517",
+"M518",
+"M519",
+"M520",
 "M521",
 "M522",
 "M523",
 "M524",
+"M525",
+## Bugbear++
+"M581",
+"M582",
 ## Format Strings
 "M601",
 "M611",
 "M612",
 "M613",
 "M501",
 "M502",
 "M503",
 "M504",
 "M505",
-"M506",
 "M507",
-"M508",
 "M509",
+"M510",
 "M511",
 "M512",
 "M513",
+"M514",
+"M515",
+"M516",
+"M517",
+"M518",
+"M519",
+"M520",
 "M521",
 "M522",
 "M523",
 "M524",
+"M525",
+"M581",
+"M582",
 ),
 ),
 (self.__checkPep3101, ("M601",)),
 (
 self.__checkFormatString,
 mutableTypes = (
 ast.Call,
 ast.Dict,
 ast.List,
 ast.Set,
+ast.DictComp,
+ast.ListComp,
+ast.SetComp,
 )
 mutableCalls = (
 "Counter",
 "OrderedDict",
 "collections.Counter",
 "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)
 self.violations.append((node, "M654"))
 super().generic_visit(node)
+BugBearContext = namedtuple("BugBearContext", ["node", "stack"])
 class BugBearVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor to check for various topics.
 """
 #
-# This class was implemented along the BugBear flake8 extension (v 19.3.0).
+# This class was implemented along the BugBear flake8 extension (v 22.9.11).
 # Original: Copyright (c) 2016 Łukasz Langa
 #
-# TODO: update to v22.7.1
+CONTEXTFUL_NODES = (
+ast.Module,
+ast.ClassDef,
+ast.AsyncFunctionDef,
+ast.FunctionDef,
+ast.Lambda,
+ast.ListComp,
+ast.SetComp,
+ast.DictComp,
+ast.GeneratorExp,
+)
+FUNCTION_NODES = (
+ast.AsyncFunctionDef,
+ast.FunctionDef,
+ast.Lambda,
+)
 NodeWindowSize = 4
 def __init__(self):
 """
 Constructor
 """
 super().__init__()
-self.__nodeStack = []
+self.nodeWindow = []
-self.__nodeWindow = []
 self.violations = []
+self.contexts = []
+self.__M523Seen = set()
+@property
+def nodeStack(self):
+"""
+Public method to get a reference to the most recent node stack.
+@return reference to the most recent node stack
+@rtype list
+"""
+if len(self.contexts) == 0:
+return []
+context, stack = self.contexts[-1]
+return stack
+def __isIdentifier(self, arg):
+"""
+Private method to check if arg is a valid identifier.
+See https://docs.python.org/2/reference/lexical_analysis.html#identifiers
+@param arg reference to an argument node
+@type ast.Node
+@return flag indicating a valid identifier
+@rtype TYPE
+"""
+if not AstUtilities.isString(arg):
+return False
+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):
+"""
+Private 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
+@return string representation
+@rtype str
+"""
+if isinstance(node, ast.Name):
+return node.id
+if isinstance(node, ast.Call):
+return self.__toNameStr(node.func)
+try:
+return self.__toNameStr(node.value) + "." + node.attr
+except AttributeError:
+return self.__toNameStr(node.value)
+def __typesafeIssubclass(self, obj, classOrTuple):
+"""
+Private method implementing a type safe issubclass() function.
+@param obj reference to the object to be tested
+@type any
+@param classOrTuple type to check against
+@type type
+@return flag indicating a subclass
+@rtype bool
+"""
+try:
+return issubclass(obj, classOrTuple)
+except TypeError:
+# User code specifies a type that is not a type in our current run.
+# Might be their error, might be a difference in our environments.
+# We don't know so we ignore this.
+return False
+def __getAssignedNames(self, loopNode):
+"""
+Private method to get the names of a for loop.
+@param loopNode reference to the node to be processed
+@type ast.For
+@yield DESCRIPTION
+@ytype TYPE
+"""
+loopTargets = (ast.For, ast.AsyncFor, ast.comprehension)
+for node in self.__childrenInScope(loopNode):
+if isinstance(node, (ast.Assign)):
+for child in node.targets:
+yield from self.__namesFromAssignments(child)
+if isinstance(node, loopTargets + (ast.AnnAssign, ast.AugAssign)):
+yield from self.__namesFromAssignments(node.target)
+def __namesFromAssignments(self, assignTarget):
+"""
+Private method to get names of an assignment.
+@param assignTarget reference to the node to be processed
+@type ast.Node
+@yield name of the assignment
+@ytype str
+"""
+if isinstance(assignTarget, ast.Name):
+yield assignTarget.id
+elif isinstance(assignTarget, ast.Starred):
+yield from self.__namesFromAssignments(assignTarget.value)
+elif isinstance(assignTarget, (ast.List, ast.Tuple)):
+for child in assignTarget.elts:
+yield from self.__namesFromAssignments(child)
+def __childrenInScope(self, node):
+"""
+Private method to get all child nodes in the given scope.
+@param node reference to the node to be processed
+@type ast.Node
+@yield reference to a child node
+@ytype ast.Node
+"""
+yield node
+if not isinstance(node, BugBearVisitor.FUNCTION_NODES):
+for child in ast.iter_child_nodes(node):
+yield from self.__childrenInScope(child)
 def visit(self, node):
 """
 Public method to traverse a given AST node.
 @param node AST node to be traversed
 @type ast.Node
 """
-self.__nodeStack.append(node)
+isContextful = isinstance(node, BugBearVisitor.CONTEXTFUL_NODES)
-self.__nodeWindow.append(node)
-self.__nodeWindow = self.__nodeWindow[-BugBearVisitor.NodeWindowSize :]
+if isContextful:
+context = BugBearContext(node, [])
+self.contexts.append(context)
+self.nodeStack.append(node)
+self.nodeWindow.append(node)
+self.nodeWindow = self.nodeWindow[-BugBearVisitor.NodeWindowSize :]
 super().visit(node)
-self.__nodeStack.pop()
+self.nodeStack.pop()
+if isContextful:
+self.contexts.pop()
+def visit_ExceptHandler(self, node):
+"""
+Public method to handle exception handlers.
+@param node reference to the node to be processed
+@type ast.ExceptHandler
+"""
+redundantExceptions = {
+"OSError": {
+# All of these are actually aliases of OSError since Python 3.3
+"IOError",
+"EnvironmentError",
+"WindowsError",
+"mmap.error",
+"socket.error",
+"select.error",
+},
+"ValueError": {
+"binascii.Error",
+},
+}
+if node.type is None:
+# bare except is handled by pycodestyle already
+pass
+elif isinstance(node.type, ast.Tuple):
+names = [self.__toNameStr(e) for e in node.type.elts]
+as_ = " as " + node.name if node.name is not None else ""
+if len(names) == 0:
+self.violations.append((node, "M501", as_))
+elif len(names) == 1:
+self.violations.append((node, "M513", *names))
+else:
+# See if any of the given exception names could be removed, e.g. from:
+#  (MyError, MyError)  # duplicate names
+#  (MyError, BaseException)  # everything derives from the Base
+#  (Exception, TypeError)  # builtins where one subclasses another
+#  (IOError, OSError)  # IOError is an alias of OSError since Python3.3
+# but note that other cases are impractical to handle from the AST.
+# We expect this is mostly useful for users who do not have the
+# builtin exception hierarchy memorised, and include a 'shadowed'
+# subtype without realising that it's redundant.
+good = sorted(set(names), key=names.index)
+if "BaseException" in good:
+good = ["BaseException"]
+# Remove redundant exceptions that the automatic system either handles
+# poorly (usually aliases) or can't be checked (e.g. it's not an
+# built-in exception).
+for primary, equivalents in redundantExceptions.items():
+if primary in good:
+good = [g for g in good if g not in equivalents]
+for name, other in itertools.permutations(tuple(good), 2):
+if (
+self.__typesafeIssubclass(
+getattr(builtins, name, type), getattr(builtins, other, ())
+)
+and name in good
+):
+good.remove(name)
+if good != names:
+desc = (
+good[0] if len(good) == 1 else "({0})".format(", ".join(good))
+)
+self.violations.append((node, "M514", ", ".join(names), as_, desc))
+self.generic_visit(node)
 def visit_UAdd(self, node):
 """
 Public method to handle unary additions.
 @param node reference to the node to be processed
 @type ast.UAdd
 """
-trailingNodes = list(map(type, self.__nodeWindow[-4:]))
+trailingNodes = list(map(type, self.nodeWindow[-4:]))
 if trailingNodes == [ast.UnaryOp, ast.UAdd, ast.UnaryOp, ast.UAdd]:
-originator = self.__nodeWindow[-4]
+originator = self.nodeWindow[-4]
-self.violations.append((originator, "M501"))
+self.violations.append((originator, "M502"))
 self.generic_visit(node)
 def visit_Call(self, node):
 """
 Public method to handle a function call.
 @param node reference to the node to be processed
 @type ast.Call
 """
-validPaths = ("six", "future.utils", "builtins")
-methodsDict = {
-"M521": ("iterkeys", "itervalues", "iteritems", "iterlists"),
-"M522": ("viewkeys", "viewvalues", "viewitems", "viewlists"),
-"M523": ("next",),
-}
 if isinstance(node.func, ast.Attribute):
-for code, methods in methodsDict.items():
+self.__checkForM505(node)
-if node.func.attr in methods:
-callPath = ".".join(composeCallPath(node.func.value))
-if callPath not in validPaths:
-self.violations.append((node, code))
-break
-else:
-self.__checkForM502(node)
 else:
 with contextlib.suppress(AttributeError, IndexError):
 # bad super() call
 if isinstance(node.func, ast.Name) and node.func.id == "super":
 args = node.args
 and isinstance(args[0], ast.Attribute)
 and isinstance(args[0].value, ast.Name)
 and args[0].value.id == "self"
 and args[0].attr == "__class__"
 ):
-self.violations.append((node, "M509"))
+self.violations.append((node, "M582"))
 # bad getattr and setattr
 if (
 node.func.id in ("getattr", "hasattr")
 and node.args[1].s == "__call__"
 ):
-self.violations.append((node, "M511"))
+self.violations.append((node, "M504"))
 if (
 node.func.id == "getattr"
 and len(node.args) == 2
-and AstUtilities.isString(node.args[1])
+and self.__isIdentifier(node.args[1])
+and iskeyword(AstUtilities.getValue(node.args[1]))
 ):
-self.violations.append((node, "M512"))
+self.violations.append((node, "M509"))
 elif (
 node.func.id == "setattr"
 and len(node.args) == 3
-and AstUtilities.isString(node.args[1])
+and self.__isIdentifier(node.args[1])
+and iskeyword(AstUtilities.getValue(node.args[1]))
 ):
-self.violations.append((node, "M513"))
+self.violations.append((node, "M510"))
 self.generic_visit(node)
-def visit_Attribute(self, node):
-"""
-Public method to handle attributes.
-@param node reference to the node to be processed
-@type ast.Attribute
-"""
-callPath = list(composeCallPath(node))
-if ".".join(callPath) == "sys.maxint":
-self.violations.append((node, "M504"))
-elif len(callPath) == 2 and callPath[1] == "message":
-name = callPath[0]
-for elem in reversed(self.__nodeStack[:-1]):
-if isinstance(elem, ast.ExceptHandler) and elem.name == name:
-self.violations.append((node, "M505"))
-break
 def visit_Assign(self, node):
 """
 Public method to handle assignments.
 @param node reference to the node to be processed
 @type ast.Assign
 """
-if isinstance(self.__nodeStack[-2], ast.ClassDef):
+if len(node.targets) == 1:
-# By using 'hasattr' below we're ignoring starred arguments, slices
-# and tuples for simplicity.
-assignTargets = {t.id for t in node.targets if hasattr(t, "id")}
-if "__metaclass__" in assignTargets:
-self.violations.append((node, "M524"))
-elif len(node.targets) == 1:
 target = node.targets[0]
 if (
 isinstance(target, ast.Attribute)
 and isinstance(target.value, ast.Name)
 and (target.value.id, target.attr) == ("os", "environ")
 ):
-self.violations.append((node, "M506"))
+self.violations.append((node, "M503"))
 self.generic_visit(node)
 def visit_For(self, node):
 """
 @param node reference to the node to be processed
 @type ast.For
 """
 self.__checkForM507(node)
+self.__checkForM520(node)
+self.__checkForM523(node)
 self.generic_visit(node)
 def visit_AsyncFor(self, node):
 """
 @param node reference to the node to be processed
 @type ast.AsyncFor
 """
 self.__checkForM507(node)
+self.__checkForM520(node)
+self.__checkForM523(node)
+self.generic_visit(node)
+def visit_While(self, node):
+"""
+Public method to handle 'while' statements.
+@param node reference to the node to be processed
+@type ast.While
+"""
+self.__checkForM523(node)
+self.generic_visit(node)
+def visit_ListComp(self, node):
+"""
+Public method to handle list comprehensions.
+@param node reference to the node to be processed
+@type ast.ListComp
+"""
+self.__checkForM523(node)
+self.generic_visit(node)
+def visit_SetComp(self, node):
+"""
+Public method to handle set comprehensions.
+@param node reference to the node to be processed
+@type ast.SetComp
+"""
+self.__checkForM523(node)
+self.generic_visit(node)
+def visit_DictComp(self, node):
+"""
+Public method to handle dictionary comprehensions.
+@param node reference to the node to be processed
+@type ast.DictComp
+"""
+self.__checkForM523(node)
+self.generic_visit(node)
+def visit_GeneratorExp(self, node):
+"""
+Public method to handle generator expressions.
+@param node reference to the node to be processed
+@type ast.GeneratorExp
+"""
+self.__checkForM523(node)
 self.generic_visit(node)
 def visit_Assert(self, node):
 """
 """
 if (
 AstUtilities.isNameConstant(node.test)
 and AstUtilities.getValue(node.test) is False
 ):
-self.violations.append((node, "M503"))
+self.violations.append((node, "M511"))
+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.__checkForM518(node)
+self.__checkForM519(node)
+self.__checkForM521(node)
+self.generic_visit(node)
+def visit_ClassDef(self, 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.__checkForM524(node)
+self.generic_visit(node)
+def visit_Try(self, node):
+"""
+Public method to handle 'try' statements'.
+@param node reference to the node to be processed
+@type ast.Try
+"""
+self.__checkForM512(node)
+self.__checkForM525(node)
+self.generic_visit(node)
+def visit_Compare(self, node):
+"""
+Public method to handle comparison statements.
+@param node reference to the node to be processed
+@type ast.Compare
+"""
+self.__checkForM515(node)
+self.generic_visit(node)
+def visit_Raise(self, node):
+"""
+Public method to handle 'raise' statements.
+@param node reference to the node to be processed
+@type ast.Raise
+"""
+self.__checkForM516(node)
+self.generic_visit(node)
+def visit_With(self, node):
+"""
+Public method to handle 'with' statements.
+@param node reference to the node to be processed
+@type ast.With
+"""
+self.__checkForM517(node)
+self.__checkForM522(node)
 self.generic_visit(node)
 def visit_JoinedStr(self, node):
 """
 """
 for value in node.values:
 if isinstance(value, ast.FormattedValue):
 return
-self.violations.append((node, "M508"))
+self.violations.append((node, "M581"))
-def __checkForM502(self, node):
+def __checkForM505(self, node):
 """
 Private method to check the use of *strip().
 @param node reference to the node to be processed
 @type ast.Call
 return  # stripping just one character
 if len(s) == len(set(s)):
 return  # no characters appear more than once
-self.violations.append((node, "M502"))
+self.violations.append((node, "M505"))
 def __checkForM507(self, node):
 """
 Private method to check for unused loop variables.
 @param node reference to the node to be processed
-@type ast.For
+@type ast.For or ast.AsyncFor
 """
 targets = NameFinder()
 targets.visit(node.target)
 ctrlNames = set(filter(lambda s: not s.startswith("_"), targets.getNames()))
 body = NameFinder()
 usedNames = set(body.getNames())
 for name in sorted(ctrlNames - usedNames):
 n = targets.getNames()[name][0]
 self.violations.append((n, "M507", name))
+def __checkForM512(self, node):
+"""
+Private method to check for return/continue/break inside finally blocks.
+@param node reference to the node to be processed
+@type ast.Try
+"""
+def _loop(node, badNodeTypes):
+if isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef)):
+return
+if isinstance(node, (ast.While, ast.For)):
+badNodeTypes = (ast.Return,)
+elif isinstance(node, badNodeTypes):
+self.violations.append((node, "M512"))
+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 __checkForM515(self, node):
+"""
+Private method to check for pointless comparisons.
+@param node reference to the node to be processed
+@type ast.Compare
+"""
+if isinstance(self.nodeStack[-2], ast.Expr):
+self.violations.append((node, "M515"))
+def __checkForM516(self, node):
+"""
+Private method to check for raising a literal instead of an exception.
+@param node reference to the node to be processed
+@type ast.Raise
+"""
+if (
+AstUtilities.isNameConstant(node.exc)
+or AstUtilities.isNumber(node.exc)
+or AstUtilities.isString(node.exc)
+):
+self.violations.append((node, "M516"))
+def __checkForM517(self, node):
+"""
+Private method to check for use of the evil syntax
+'with assertRaises(Exception):.
+@param node reference to the node to be processed
+@type ast.With
+"""
+item = node.items[0]
+itemContext = item.context_expr
+if (
+hasattr(itemContext, "func")
+and hasattr(itemContext.func, "attr")
+and itemContext.func.attr == "assertRaises"
+and len(itemContext.args) == 1
+and isinstance(itemContext.args[0], ast.Name)
+and itemContext.args[0].id == "Exception"
+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
+"""
+subnodeClasses = (
+(
+ast.Constant,
+ast.List,
+ast.Set,
+ast.Dict,
+)
+if sys.version_info >= (3, 8, 0)
+else (
+ast.Num,
+ast.Bytes,
+ast.NameConstant,
+ast.List,
+ast.Set,
+ast.Dict,
+)
+)
+for subnode in node.body:
+if not isinstance(subnode, ast.Expr):
+continue
+if isinstance(subnode.value, subnodeClasses) and not AstUtilities.isString(
+subnode.value
+):
+self.violations.append((subnode, "M518"))
+def __checkForM519(self, node):
+"""
+Private method to check for use of 'functools.lru_cache' or 'functools.cache'.
+@param node reference to the node to be processed
+@type ast.FunctionDef
+"""
+caches = {
+"functools.cache",
+"functools.lru_cache",
+"cache",
+"lru_cache",
+}
+if (
+len(node.decorator_list) == 0
+or len(self.contexts) < 2
+or not isinstance(self.contexts[-2].node, ast.ClassDef)
+):
+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))
+for decorator in node.decorator_list
+)
+for idx, decorator in enumerate(resolvedDecorators):
+if decorator in {"classmethod", "staticmethod"}:
+return
+if decorator in caches:
+self.violations.append((node.decorator_list[idx], "M519"))
+return
+def __checkForM520(self, node):
+"""
+Private method to check for a loop that modifies its iterable.
+@param node reference to the node to be processed
+@type ast.For or ast.AsyncFor
+"""
+targets = NameFinder()
+targets.visit(node.target)
+ctrlNames = set(targets.getNames())
+iterset = M520NameFinder()
+iterset.visit(node.iter)
+itersetNames = set(iterset.getNames())
+for name in sorted(ctrlNames):
+if name in itersetNames:
+n = targets.getNames()[name][0]
+self.violations.append((n, "M520"))
+def __checkForM521(self, node):
+"""
+Private method to check for use of an f-string as docstring.
+@param node reference to the node to be processed
+@type ast.FunctionDef or ast.ClassDef
+"""
+if (
+node.body
+and isinstance(node.body[0], ast.Expr)
+and isinstance(node.body[0].value, ast.JoinedStr)
+):
+self.violations.append((node.body[0].value, "M521"))
+def __checkForM522(self, node):
+"""
+Private method to check for use of an f-string as docstring.
+@param node reference to the node to be processed
+@type ast.With
+"""
+item = node.items[0]
+itemContext = item.context_expr
+if (
+hasattr(itemContext, "func")
+and hasattr(itemContext.func, "value")
+and hasattr(itemContext.func.value, "id")
+and itemContext.func.value.id == "contextlib"
+and hasattr(itemContext.func, "attr")
+and itemContext.func.attr == "suppress"
+and len(itemContext.args) == 0
+):
+self.violations.append((node, "M522"))
+def __checkForM523(self, loopNode):
+"""
+Private method to check that functions (including lambdas) do not use loop
+variables.
+@param loopNode reference to the node to be processed
+@type ast.For, ast.AsyncFor, ast.While, ast.ListComp, ast.SetComp,ast.DictComp,
+or ast.GeneratorExp
+"""
+suspiciousVariables = []
+for node in ast.walk(loopNode):
+if isinstance(node, BugBearVisitor.FUNCTION_NODES):
+argnames = {
+arg.arg for arg in ast.walk(node.args) if isinstance(arg, ast.arg)
+}
+if isinstance(node, ast.Lambda):
+bodyNodes = ast.walk(node.body)
+else:
+bodyNodes = itertools.chain.from_iterable(map(ast.walk, node.body))
+for name in bodyNodes:
+if (
+isinstance(name, ast.Name)
+and name.id not in argnames
+and isinstance(name.ctx, ast.Load)
+):
+err = (name.lineno, name.col_offset, name.id, name)
+if err not in self.__M523Seen:
+self.__M523Seen.add(err)  # dedupe across nested loops
+suspiciousVariables.append(err)
+if suspiciousVariables:
+reassignedInLoop = set(self.__getAssignedNames(loopNode))
+for err in sorted(suspiciousVariables):
+if reassignedInLoop.issuperset(err[2]):
+self.violations.append((err[3], "M523", err[2]))
+def __checkForM524(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
+@type ast.ClassDef
+"""  # __IGNORE_WARNING_D234r__
+def isAbcClass(value):
+if isinstance(value, ast.keyword):
+return value.arg == "metaclass" and isAbcClass(value.value)
+abcNames = ("ABC", "ABCMeta")
+return (isinstance(value, ast.Name) and value.id in abcNames) or (
+isinstance(value, ast.Attribute)
+and value.attr in abcNames
+and isinstance(value.value, ast.Name)
+and value.value.id == "abc"
+)
+def isAbstractDecorator(expr):
+return (isinstance(expr, ast.Name) and expr.id[:8] == "abstract") or (
+isinstance(expr, ast.Attribute) and expr.attr[:8] == "abstract"
+)
+if not any(map(isAbcClass, (*node.bases, *node.keywords))):
+return
+for stmt in node.body:
+if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)) and any(
+map(isAbstractDecorator, stmt.decorator_list)
+):
+return
+self.violations.append((node, "M524", node.name))
+def __checkForM525(self, node):
+"""
+Private method to check for exceptions being handled multiple times.
+@param node reference to the node to be processed
+@type ast.Try
+"""
+seen = []
+for handler in node.handlers:
+if isinstance(handler.type, (ast.Name, ast.Attribute)):
+name = ".".join(self.__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))
+uniques.add(name)
+seen.extend(uniques)
+# sort to have a deterministic output
+duplicates = sorted({x for x in seen if seen.count(x) > 1})
+for duplicate in duplicates:
+self.violations.append((node, "M525", duplicate))
 class NameFinder(ast.NodeVisitor):
 """
 Class to extract a name out of a tree of nodes.
 """
 """
 Public method to traverse a given AST node.
 @param node AST node to be traversed
 @type ast.Node
+@return reference to the last processed node
+@rtype ast.Node
 """
 if isinstance(node, list):
 for elem in node:
 super().visit(elem)
+return node
 else:
-super().visit(node)
+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 M520NameFinder(NameFinder):
+"""
+Class to extract a name out of a tree of nodes ignoring names defined within the
+local scope of a comprehension.
+"""
+def visit_GeneratorExp(self, node):
+"""
+Public method to handle a generator expressions.
+@param node reference to the node to be processed
+@type ast.GeneratorExp
+"""
+self.visit(node.generators)
+def visit_ListComp(self, node):
+"""
+Public method  to handle a list comprehension.
+@param node reference to the node to be processed
+@type TYPE
+"""
+self.visit(node.generators)
+def visit_DictComp(self, node):
+"""
+Public method  to handle a dictionary comprehension.
+@param node reference to the node to be processed
+@type TYPE
+"""
+self.visit(node.generators)
+def visit_comprehension(self, node):
+"""
+Public method  to handle the 'for' of a comprehension.
+@param node reference to the node to be processed
+@type ast.comprehension
+"""
+self.visit(node.iter)
+def visit_Lambda(self, node):
+"""
+Public method  to handle a Lambda function.
+@param node reference to the node to be processed
+@type ast.Lambda
+"""
+self.visit(node.body)
+for lambdaArg in node.args.args:
+self.getNames().pop(lambdaArg.arg, None)
 class ReturnVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor to check return statements.

Mercurial Repositories > eric / file comparison

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

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