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

-:9ffdb1490bd2
+:e6ff9a4f6ee5
 import builtins
 import contextlib
 import copy
 import itertools
 import re
+import sys
 import tokenize
 from collections import defaultdict, namedtuple
 from keyword import iskeyword
 from string import Formatter
+try:
+# Python 3.10+
+from itertools import pairwise
+except ImportError:
+# replacement for Python < 3.10
+from itertools import tee
+def pairwise(iterable):
+a, b = tee(iterable)
+next(b, None)
+return zip(a, b)
 import AstUtilities
 from .eradicate import Eradicator
 from .MiscellaneousDefaults import MiscellaneousCheckerDefaultArgs
 "M182",
 "M183",
 "M184",
 "M185",
 "M186",
-"M187",
 "M188",
 "M189",
+"M189a",
+"M189b",
 "M190",
+"M190a",
+"M190b",
 "M191",
-"M192",
 "M193",
+"M193a",
+"M193b",
+"M193c",
 "M194",
 "M195",
+"M196",
+"M197",
+"M198",
+"M199",
 ## Dictionaries with sorted keys
 "M201",
 ## Property
 "M210",
 "M211",
 "M832",
 "M833",
 "M834",
 ## line continuation
 "M841",
+## implicitly concatenated strings
+"M851",
+"M852",
+"M853",
 ## commented code
 "M891",
 ]
 Formatter = Formatter()
 self.__filename = filename
 self.__source = source[:]
 self.__tree = copy.deepcopy(tree)
 self.__args = args
+linesIterator = iter(self.__source)
+self.__tokens = list(tokenize.generate_tokens(lambda: next(linesIterator)))
 self.__pep3101FormatRegex = re.compile(
 r'^(?:[^\'"]*[\'"][^\'"]*[\'"])*\s*%|^\s*%'
 )
 self.__builtins = [b for b in dir(builtins) if b not in self.BuiltinsWhiteList]
 "M182",
 "M183",
 "M184",
 "M185",
 "M186",
-"M187",
 "M188",
 "M189",
+"M189a",
+"M189b",
 "M190",
+"M190a",
+"M190b",
 "M191",
-"M192",
 "M193",
+"M193a",
+"M193b",
+"M193c",
 "M194",
 "M195",
+"M196",
+"M197",
+"M198",
+"M199",
 ),
 ),
 (self.__checkDictWithSortedKeys, ("M201",)),
 (
 self.__checkProperties,
 (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",)),
 ]
 # the eradicate whitelist
 commentedCodeCheckerArgs = self.__args.get(
 def __checkLineContinuation(self):
 """
 Private method to check line continuation using backslash.
 """
 # generate source lines without comments
-linesIterator = iter(self.__source)
+comments = [tok for tok in self.__tokens if tok[0] == tokenize.COMMENT]
-tokens = tokenize.generate_tokens(lambda: next(linesIterator))
-comments = [token for token in tokens if token[0] == tokenize.COMMENT]
 stripped = self.__source[:]
 for comment in comments:
 lineno = comment[3][0]
 start = comment[2][1]
 stop = comment[3][1]
 ):
 errorCode = {
 "tuple": "M189a",
 "list": "M190a",
 }[node.func.id]
-##suffix = "remove the outer call to {func}()."
 self.__error(
 node.lineno - 1,
 node.col_offset,
 errorCode,
 type(node.args[0]).__name__.lower(),
 for elt in node.args[0].elts
 )
 )
 )
 ):
-##suffix = "rewrite as a {func} literal."
 errorCode = {
 "tuple": "M189b",
 "list": "M190b",
 "set": "M185",
 "dict": "M186",
 "M193b",
 node.func.id,
 node.args[0].func.id,
 not reverseFlagValue,
 )
-##if reverse_flag_value is None:
-##remediation = " - toggle reverse argument to sorted()"
-##else:
-##remediation = " - use sorted(..., reverse={!r})".format(
-##not reverse_flag_value
-##)
 else:
 self.__error(
 node.lineno - 1,
 node.col_offset,
 node.func.id == "map"
 and node not in visitedMapCalls
 and len(node.args) == 2
 and isinstance(node.args[0], ast.Lambda)
 ):
-self.__error(node.lineno - 1, node.col_offset, "M197", "generator expression")
+self.__error(
+node.lineno - 1, node.col_offset, "M197", "generator expression"
+)
 elif (
 node.func.id in ("list", "set", "dict")
 and len(node.args) == 1
 and isinstance(node.args[0], ast.Call)
 ):
 rewriteable = False
 if rewriteable:
 comprehensionType = f"{node.func.id} comprehension"
-self.__error(node.lineno - 1, node.col_offset, "M197", comprehensionType)
+self.__error(
+node.lineno - 1, node.col_offset, "M197", comprehensionType
+)
 elif isinstance(node, (ast.DictComp, ast.ListComp, ast.SetComp)) and (
 len(node.generators) == 1
 and not node.generators[0].ifs
 and not node.generators[0].is_async
 len(node.args.args),
 )
 if propertyCount > 1:
 self.__error(node.lineno - 1, node.col_offset, "M217", node.name)
+#######################################################################
+## The following method check for implicitly concatenated strings
+##
+## These methods are adapted from: flake8-implicit-str-concat v0.4.0
+## Original: Copyright (c) 2023 Dylan Turner
+#######################################################################
+if sys.version_info < (3, 12):
+def __isImplicitStringConcat(self, first, second):
+"""
+Private method to check, if the given strings indicate an implicit string
+concatenation.
+@param first first token
+@type tuple
+@param second second token
+@type tuple
+@return flag indicating an implicit string concatenation
+"""
+return first.type == second.type == tokenize.STRING
+else:
+def __isImplicitStringConcat(self, first, second):
+"""
+Private method to check, if the given strings indicate an implicit string
+concatenation.
+@param first first token
+@type tuple
+@param second second token
+@type tuple
+@return flag indicating an implicit string concatenation
+"""
+return (
+(first.type == second.type == tokenize.STRING)
+or (
+first.type == tokenize.STRING
+and second.type == tokenize.FSTRING_START
+)
+or (
+first.type == tokenize.FSTRING_END
+and second.type == tokenize.STRING
+)
+or (
+first.type == tokenize.FSTRING_END
+and second.type == tokenize.FSTRING_START
+)
+)
+def __checkImplicitStringConcat(self):
+"""
+Private method to check for implicitly concatenated strings.
+"""
+tokensWithoutWhitespace = (
+tok
+for tok in self.__tokens
+if tok.type
+not in (
+tokenize.NL,
+tokenize.NEWLINE,
+tokenize.INDENT,
+tokenize.DEDENT,
+tokenize.COMMENT,
+)
+)
+for a, b in pairwise(tokensWithoutWhitespace):
+if self.__isImplicitStringConcat(a, b):
+self.__error(
+a.end[0] - 1, a.end[1], "M851" if a.end[0] == b.start[0] else "M852"
+)
+def __checkExplicitStringConcat(self):
+"""
+Private method to check for explicitly concatenated strings.
+"""
+for node in ast.walk(self.__tree):
+if (
+isinstance(node, ast.BinOp)
+and isinstance(node.op, ast.Add)
+and all(
+AstUtilities.isBaseString(operand)
+or isinstance(operand, ast.JoinedStr)
+for operand in (node.left, node.right)
+)
+):
+self.__error(node.lineno - 1, node.col_offset, "M853")
 class TextVisitor(ast.NodeVisitor):
 """
 Class implementing a node visitor for bytes and str instances.

Mercurial Repositories > eric / file comparison

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

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