eric: comparison eric6/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

-:fb0ef164f536
+:698ae46f40a4
 import re
 import itertools
 from string import Formatter
 from collections import defaultdict
 import tokenize
+import copy
+import contextlib
 import AstUtilities
 from .eradicate import Eradicator
 @type ast.Node
 @yield call path components
 @ytype str
 """
 if isinstance(node, ast.Attribute):
-for v in composeCallPath(node.value):
+yield from composeCallPath(node.value)
-yield v
 yield node.attr
 elif isinstance(node, ast.Name):
 yield node.id
-class MiscellaneousChecker(object):
+class MiscellaneousChecker:
 """
 Class implementing a checker for miscellaneous checks.
 """
 Codes = [
 ## Coding line
 ## line continuation
 "M841",
 ## commented code
 "M891",
-## syntax error
-"M901",
 ]
 Formatter = Formatter()
 FormatFieldRegex = re.compile(r'^((?:\s|.)*?)(\..*|\[.*\])?$')
 "__name__",
 "__doc__",
 "credits",
 ]
-def __init__(self, source, filename, select, ignore, expected, repeat,
+def __init__(self, source, filename, tree, select, ignore, expected,
-args):
+repeat, args):
 """
 Constructor
 @param source source code to be checked
 @type list of str
 @param filename name of the source file
 @type str
+@param tree AST tree of the source code
+@type ast.Module
 @param select list of selected codes
 @type list of str
 @param ignore list of codes to be ignored
 @type list of str
 @param expected list of expected codes
 self.__ignore = ('',) if select else tuple(ignore)
 self.__expected = expected[:]
 self.__repeat = repeat
 self.__filename = filename
 self.__source = source[:]
+self.__tree = copy.deepcopy(tree)
 self.__args = args
 self.__pep3101FormatRegex = re.compile(
 r'^(?:[^\'"]*[\'"][^\'"]*[\'"])*\s*%|^\s*%')
 "code": code,
 "args": args,
 }
 )
-def __reportInvalidSyntax(self):
-"""
-Private method to report a syntax error.
-"""
-exc_type, exc = sys.exc_info()[:2]
-if len(exc.args) > 1:
-offset = exc.args[1]
-if len(offset) > 2:
-offset = offset[1:3]
-else:
-offset = (1, 0)
-self.__error(offset[0] - 1, offset[1] or 0,
-'M901', exc_type.__name__, exc.args[0])
-def __generateTree(self):
-"""
-Private method to generate an AST for our source.
-@return generated AST
-@rtype ast.AST
-"""
-return ast.parse("".join(self.__source), self.__filename)
 def run(self):
 """
 Public method to check the given source against miscellaneous
 conditions.
 """
 # don't do anything, if essential data is missing
 return
 if not self.__checkers:
 # don't do anything, if no codes were selected
-return
-try:
-self.__tree = self.__generateTree()
-except (SyntaxError, TypeError):
-self.__reportInvalidSyntax()
 return
 for check in self.__checkers:
 check()
 break
 if isinstance(node, ast.Module) or not hasCode:
 return
-if not (imports >= expectedImports):
+if imports < expectedImports:
 if imports:
 self.__error(node.lineno - 1, node.col_offset, "M701",
 ", ".join(expectedImports), ", ".join(imports))
 else:
 self.__error(node.lineno - 1, node.col_offset, "M702",
 if hasStarArgs:
 numArgs -= 1
 # if starargs or kwargs is not None, it can't count the
 # parameters but at least check if the args are used
-if hasKwArgs:
+if hasKwArgs and not names:
-if not names:
+# No names but kwargs
-# No names but kwargs
+self.__error(call.lineno - 1, call.col_offset, "M623")
-self.__error(call.lineno - 1, call.col_offset, "M623")
+if hasStarArgs and not numbers:
-if hasStarArgs:
+# No numbers but args
-if not numbers:
+self.__error(call.lineno - 1, call.col_offset, "M624")
-# No numbers but args
-self.__error(call.lineno - 1, call.col_offset, "M624")
 if not hasKwArgs and not hasStarArgs:
 # can actually verify numbers and names
 for number in sorted(numbers):
 if number >= numArgs:
 def __checkBuiltins(self):
 """
 Private method to check, if built-ins are shadowed.
 """
 functionDefs = [ast.FunctionDef]
-try:
+with contextlib.suppress(AttributeError):
 functionDefs.append(ast.AsyncFunctionDef)
-except AttributeError:
-pass
 ignoreBuiltinAssignments = self.__args.get(
 "BuiltinsChecker",
 MiscellaneousCheckerDefaultArgs["BuiltinsChecker"])
 immutableCalls = (
 "tuple",
 "frozenset",
 )
 functionDefs = [ast.FunctionDef]
-try:
+with contextlib.suppress(AttributeError):
 functionDefs.append(ast.AsyncFunctionDef)
-except AttributeError:
-pass
 for node in ast.walk(self.__tree):
 if any(isinstance(node, functionDef)
 for functionDef in functionDefs):
 defaults = node.args.defaults[:]
-try:
+with contextlib.suppress(AttributeError):
 defaults += node.args.kw_defaults[:]
-except AttributeError:
-pass
 for default in defaults:
 if any(isinstance(default, mutableType)
 for mutableType in mutableTypes):
 typeName = type(default).__name__
 if isinstance(default, ast.Call):
 """
 Private method to check use of naive datetime functions.
 """
 # step 1: generate an augmented node tree containing parent info
 #         for each child node
-tree = self.__generateTree()
+tree = copy.deepcopy(self.__tree)
 for node in ast.walk(tree):
 for childNode in ast.iter_child_nodes(node):
 childNode._dtCheckerParent = node
 # step 2: perform checks and report issues
 def __init__(self):
 """
 Constructor
 """
-super(TextVisitor, self).__init__()
+super().__init__()
 self.nodes = []
 self.calls = {}
 def __addNode(self, node):
 """
 """
 if sys.version_info >= (3, 8, 0):
 if AstUtilities.isBaseString(node):
 self.__addNode(node)
 else:
-super(TextVisitor, self).generic_visit(node)
+super().generic_visit(node)
 else:
-super(TextVisitor, self).generic_visit(node)
+super().generic_visit(node)
 def __visitDefinition(self, node):
 """
 Private method handling class and function definitions.
 node.func.value.id == 'str' and
 node.args and
 AstUtilities.isBaseString(node.args[0])
 ):
 self.calls[node.args[0]] = (node, True)
-super(TextVisitor, self).generic_visit(node)
+super().generic_visit(node)
 class LoggingVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor to check logging statements.
 def __init__(self):
 """
 Constructor
 """
-super(LoggingVisitor, self).__init__()
+super().__init__()
 self.__currentLoggingCall = None
 self.__currentLoggingArgument = None
 self.__currentLoggingLevel = None
 self.__currentExtraKeyword = None
 @param node reference to the node to be processed
 @type ast.Call
 @return logging level
 @rtype str or None
 """
-try:
+with contextlib.suppress(AttributeError):
 if node.func.value.id == "warnings":
 return None
 if node.func.attr in LoggingVisitor.LoggingLevels:
 return node.func.attr
-except AttributeError:
-pass
 return None
 def __isFormatCall(self, node):
 """
 @param node reference to the node to be processed
 @type ast.Call
 """
 # we are in a logging statement
-if self.__withinLoggingStatement():
+if (
-if self.__withinLoggingArgument() and self.__isFormatCall(node):
+self.__withinLoggingStatement() and
-self.violations.append((node, "M651"))
+self.__withinLoggingArgument() and
-super(LoggingVisitor, self).generic_visit(node)
+self.__isFormatCall(node)
-return
+):
+self.violations.append((node, "M651"))
+super().generic_visit(node)
+return
 loggingLevel = self.__detectLoggingLevel(node)
 if loggingLevel and self.__currentLoggingLevel is None:
 self.__currentLoggingLevel = loggingLevel
 # we are in some other statement
 if loggingLevel is None:
-super(LoggingVisitor, self).generic_visit(node)
+super().generic_visit(node)
 return
 # we are entering a new logging statement
 self.__currentLoggingCall = node
 isinstance(child, ast.keyword) and
 child.arg == "extra"
 ):
 self.__currentExtraKeyword = child
-super(LoggingVisitor, self).visit(child)
+super().visit(child)
 self.__currentLoggingArgument = None
 self.__currentExtraKeyword = None
 self.__currentLoggingCall = None
 # handle string concat
 if isinstance(node.op, ast.Add):
 self.violations.append((node, "M653"))
-super(LoggingVisitor, self).generic_visit(node)
+super().generic_visit(node)
 def visit_JoinedStr(self, node):
 """
 Public method to handle f-string arguments.
 @param node reference to the node to be processed
 @type ast.JoinedStr
 """
-if self.__withinLoggingStatement():
+if (
-if any(isinstance(i, ast.FormattedValue) for i in node.values):
+self.__withinLoggingStatement() and
-if self.__withinLoggingArgument():
+any(isinstance(i, ast.FormattedValue) for i in node.values) and
-self.violations.append((node, "M654"))
+self.__withinLoggingArgument()
+):
-super(LoggingVisitor, self).generic_visit(node)
+self.violations.append((node, "M654"))
+super().generic_visit(node)
 class BugBearVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor to check for various topics.
 def __init__(self):
 """
 Constructor
 """
-super(BugBearVisitor, self).__init__()
+super().__init__()
 self.__nodeStack = []
 self.__nodeWindow = []
 self.violations = []
 """
 self.__nodeStack.append(node)
 self.__nodeWindow.append(node)
 self.__nodeWindow = self.__nodeWindow[-BugBearVisitor.NodeWindowSize:]
-super(BugBearVisitor, self).visit(node)
+super().visit(node)
 self.__nodeStack.pop()
 def visit_UAdd(self, node):
 """
 self.violations.append((node, code))
 break
 else:
 self.__checkForM502(node)
 else:
-try:
+with contextlib.suppress(AttributeError, IndexError):
 # bad super() call
 if isinstance(node.func, ast.Name) and node.func.id == "super":
 args = node.args
 if (
 len(args) == 2 and
 node.func.id == "setattr" and
 len(node.args) == 3 and
 AstUtilities.isString(node.args[1])
 ):
 self.violations.append((node, "M513"))
-except (AttributeError, IndexError):
-pass
 self.generic_visit(node)
 def visit_Attribute(self, node):
 """
 elif len(node.targets) == 1:
 target = node.targets[0]
 if (
 isinstance(target, ast.Attribute) and
-isinstance(target.value, ast.Name)
+isinstance(target.value, ast.Name) and
+(target.value.id, target.attr) == ('os', 'environ')
 ):
-if (target.value.id, target.attr) == ('os', 'environ'):
+self.violations.append((node, "M506"))
-self.violations.append((node, "M506"))
 self.generic_visit(node)
 def visit_For(self, node):
 """
 """
 def __init__(self):
 """
 Constructor
 """
-super(NameFinder, self).__init__()
+super().__init__()
 self.__names = {}
 def visit_Name(self, node):
 """
 @param node AST node to be traversed
 @type ast.Node
 """
 if isinstance(node, list):
 for elem in node:
-super(NameFinder, self).visit(elem)
+super().visit(elem)
 else:
-super(NameFinder, self).visit(node)
+super().visit(node)
 def getNames(self):
 """
 Public method to return the extracted names and Name nodes.
 def __init__(self):
 """
 Constructor
 """
-super(ReturnVisitor, self).__init__()
+super().__init__()
 self.__stack = []
 self.violations = []
 self.__loopCount = 0
 """
 def __init__(self):
 """
 Constructor
 """
-super(DateTimeVisitor, self).__init__()
+super().__init__()
 self.violations = []
 def __getFromKeywords(self, keywords, name):
 """
 elif node.func.attr == 'strptime':
 # datetime.strptime(...).replace(tzinfo=UTC)
 parent = getattr(node, '_dtCheckerParent', None)
 pparent = getattr(parent, '_dtCheckerParent', None)
-if not (isinstance(parent, ast.Attribute) and
+if (
-parent.attr == 'replace'):
+not (isinstance(parent, ast.Attribute) and
-isCase1 = False
+parent.attr == 'replace') or
-elif not isinstance(pparent, ast.Call):
+not isinstance(pparent, ast.Call)
+):
 isCase1 = False
 else:
 tzinfoKeyword = self.__getFromKeywords(pparent.keywords,
 'tzinfo')
 isCase1 = (
 """
 def __init__(self):
 """
 Constructor
 """
-super(SysVersionVisitor, self).__init__()
+super().__init__()
 self.violations = []
 self.__fromImports = {}
 def visit_ImportFrom(self, node):
 @return flag indicating a match
 @rtype bool
 """
 match = False
 if (
-isinstance(node, ast.Attribute) and
+(isinstance(node, ast.Attribute) and
 isinstance(node.value, ast.Name) and
 node.value.id == "sys" and
-node.attr == attr
+node.attr == attr) or
-):
+(isinstance(node, ast.Name) and
-match = True
+node.id == attr and
-elif (
+self.__fromImports.get(node.id) == "sys")
-isinstance(node, ast.Name) and
-node.id == attr and
-self.__fromImports.get(node.id) == "sys"
 ):
 match = True
 return match

Mercurial Repositories > eric / file comparison

comparison: eric6/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

eric6/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py