eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py

-:fc45672fae42
+:73d80859079c
 @param node reference to the AST node to be checked
 @type ast.BoolOp
 """
 if isinstance(node.op, ast.Or):
 for variable in self.__getDuplicatedIsinstanceCall(node):
-self.__error(node.lineno - 1, node.col_offset, "Y-101", variable)
+self.__error(node, "Y-101", variable)
 def __check102(self, node):
 """
 Private method to check for nested if statements without else blocks.
 #     pass
 # elif b:  <--- this is treated like a nested block
 #     if c: <---
 #         d
 if isPattern1:
-self.__error(node.lineno - 1, node.col_offset, "Y-102")
+self.__error(node, "Y-102")
 def __check103(self, node):
 """
 Private method to check for calls that wrap a condition to return
 a bool.
 node.orelse[0].value.value is True
 or node.orelse[0].value.value is False
 )
 ):
 condition = unparse(node.test)
-self.__error(node.lineno - 1, node.col_offset, "Y-103", condition)
+self.__error(node, "Y-103", condition)
 def __check104(self, node):
 """
 Private method to check for "iterate and yield" patterns.
 ):
 parent = getattr(parent, "parent", None)
 if not isinstance(parent, ast.AsyncFunctionDef):
 iterable = unparse(node.iter)
-self.__error(node.lineno - 1, node.col_offset, "Y-104", iterable)
+self.__error(node, "Y-104", iterable)
 def __check105(self, node):
 """
 Private method to check for "try-except-pass" patterns.
 exception = "Exception"
 elif isinstance(node.handlers[0].type, ast.Tuple):
 exception = ", ".join([unparse(n) for n in node.handlers[0].type.elts])
 else:
 exception = unparse(node.handlers[0].type)
-self.__error(node.lineno - 1, node.col_offset, "Y-105", exception)
+self.__error(node, "Y-105", exception)
 def __check106(self, node):
 """
 Private method to check for calls where an exception is raised in else.
 and len(node.orelse) >= 1
 and isinstance(node.orelse[-1], ast.Raise)
 and not isinstance(node.body[-1], ast.Raise)
 )
 if just_one or many:
-self.__error(node.lineno - 1, node.col_offset, "Y-106")
+self.__error(node, "Y-106")
 def __check107(self, node):
 """
 Private method to check for calls where try/except and finally have
 'return'.
 finallyHasReturn = True
 finallyReturn = stmt
 break
 if (tryHasReturn or exceptHasReturn) and finallyHasReturn:
-self.__error(finallyReturn.lineno - 1, finallyReturn.col_offset, "Y-107")
+self.__error(finallyReturn, "Y-107")
 def __check108(self, node):
 """
 Private method to check for if-elses which could be a ternary
 operator assignment.
 body = unparse(node.body[0].value)
 cond = unparse(node.test)
 orelse = unparse(node.orelse[0].value)
-self.__error(
+self.__error(node, "Y-108", assign, body, cond, orelse)
-node.lineno - 1, node.col_offset, "Y-108", assign, body, cond, orelse
-)
 def __check109(self, node):
 """
 Private method to check for multiple equalities with the same value
 are combined via "or".
 for value, values in id2count.items():
 if len(values) == 1:
 continue
 self.__error(
-node.lineno - 1,
+node, "Y-109", value, unparse(ast.Tuple(elts=values)), unparse(node)
-node.col_offset,
-"Y-109",
-value,
-unparse(ast.Tuple(elts=values)),
-unparse(node),
 )
 def __check110_111(self, node):
 """
 Private method to check if any / all could be used.
 ):
 check = unparse(node.body[0].test)
 target = unparse(node.target)
 iterable = unparse(node.iter)
 if node.body[0].body[0].value.value is True:
-self.__error(
+self.__error(node, "Y-110", check, target, iterable)
-node.lineno - 1, node.col_offset, "Y-110", check, target, iterable
-)
 elif node.body[0].body[0].value.value is False:
 isCompoundExpression = " and " in check or " or " in check
 if isCompoundExpression:
 check = f"not ({check})"
 else:
 if check.startswith("not "):
 check = check[len("not ") :]
 else:
 check = f"not {check}"
-self.__error(
+self.__error(node, "Y-111", check, target, iterable)
-node.lineno - 1, node.col_offset, "Y-111", check, target, iterable
-)
 def __check112(self, node):
 """
 Private method to check for non-capitalized calls to environment
 variables.
 defaultValue = unparse(node.value.args[1])
 expected = f"os.environ.get('{envName.upper()}', '{defaultValue}')"
 else:
 return
-self.__error(node.lineno - 1, node.col_offset, "Y-112", expected, original)
+self.__error(node, "Y-112", expected, original)
 def __check113(self, node):
 """
 Private method to check for loops in which "enumerate" should be
 used.
 while sibling is not None:
 sibling = sibling.previous_sibling
 for match in matches:
 variable = unparse(match)
-self.__error(match.lineno - 1, match.col_offset, "Y-113", variable)
+self.__error(match, "Y-113", variable)
 def __check114(self, node):
 """
 Private method to check for alternative if clauses with identical
 bodies.
 ifbody1 = ifBodyPairs[i]
 ifbody2 = ifBodyPairs[i + 1]
 if self.__isSameBody(ifbody1[1], ifbody2[1]):
 errorPairs.append((ifbody1, ifbody2))
 for ifbody1, ifbody2 in errorPairs:
-self.__error(
+self.__error(ifbody1[0], "Y-114", unparse(ifbody1[0]), unparse(ifbody2[0]))
-ifbody1[0].lineno - 1,
-ifbody1[0].col_offset,
-"Y-114",
-unparse(ifbody1[0]),
-unparse(ifbody2[0]),
-)
 def __check115(self, node):
 """
 Private method to to check for places where open() is called without
 a context handler.
 if (
 isinstance(node.func, ast.Name)
 and node.func.id == "open"
 and not isinstance(node.parent, ast.withitem)
 ):
-self.__error(node.lineno - 1, node.col_offset, "Y-115")
+self.__error(node, "Y-115")
 def __check116(self, node):
 """
 Private method to check for places with 3 or more consecutive
 if-statements with direct returns.
 if elseValue:
 ret = f"{keyValuePairs}.get({variable.id}, {elseValue})"
 else:
 ret = f"{keyValuePairs}.get({variable.id})"
-self.__error(node.lineno - 1, node.col_offset, "Y-116", ret)
+self.__error(node, "Y-116", ret)
 def __check117(self, node):
 """
 Private method to check for multiple with-statements with same scope.
 if len(node.body) == 1 and isinstance(node.body[0], ast.With):
 withItems = []
 for withitem in node.items + node.body[0].items:
 withItems.append(f"{unparse(withitem)}")
 mergedWith = f"with {', '.join(withItems)}:"
-self.__error(node.lineno - 1, node.col_offset, "Y-117", mergedWith)
+self.__error(node, "Y-117", mergedWith)
 def __check118(self, node):
 """
 Private method to check for usages of "key in dict.keys()".
 if isinstance(node, ast.Compare):
 keyStr = unparse(node.left)
 else:
 keyStr = unparse(node.target)
 dictStr = unparse(attrNode.value)
-self.__error(node.lineno - 1, node.col_offset, "Y-118", keyStr, dictStr)
+self.__error(node, "Y-118", keyStr, dictStr)
 def __check119(self, node):
 """
 Private method to check for classes that should be "dataclasses".
 if (
 hasOnlyConstructorMethod
 and sum(1 for el in node.body if isinstance(el, ast.FunctionDef)) > 0
 ):
-self.__error(node.lineno - 1, node.col_offset, "Y-119", node.name)
+self.__error(node, "Y-119", node.name)
 def __check120_121(self, node):
 """
 Private method to check for classes that inherit from object.
 if (
 len(node.bases) == 1
 and isinstance(node.bases[0], ast.Name)
 and node.bases[0].id == "object"
 ):
-self.__error(node.lineno - 1, node.col_offset, "Y-120", node.name)
+self.__error(node, "Y-120", node.name)
 elif (
 len(node.bases) > 1
 and isinstance(node.bases[-1], ast.Name)
 and node.bases[-1].id == "object"
 ):
 self.__error(
-node.lineno - 1,
+node, "Y-121", node.name, ", ".join(b.id for b in node.bases[:-1])
-node.col_offset,
-"Y-121",
-node.name,
-", ".join(b.id for b in node.bases[:-1]),
 )
 def __check122(self, node):
 """
 Private method to check for all if-blocks which only check if a key
 and isinstance(node.test.comparators[0], ast.Name)
 and node.body[0].value.value.id == node.test.comparators[0].id
 ):
 key = unparse(node.test.left)
 dictname = unparse(node.test.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-122", dictname, key)
+self.__error(node, "Y-122", dictname, key)
 def __check123(self, node):
 """
 Private method to check for complicated dictionary access with default value.
 dictStr = unparse(dictName)
 defaultStr = unparse(defaultValue)
 valueStr = unparse(valueNode)
 else:
 return
-self.__error(
+self.__error(node, "Y-123", valueStr, dictStr, keyStr, defaultStr)
-node.lineno - 1,
-node.col_offset,
-"Y-123",
-valueStr,
-dictStr,
-keyStr,
-defaultStr,
-)
 def __check181(self, node):
 """
 Private method to check for assignments that could be converted into
 an augmented assignment.
 and isinstance(node.value.left, ast.Name)
 and node.value.left.id == node.targets[0].id
 and not isinstance(node.value.right, ast.Tuple)
 ):
 newNode = ast.AugAssign(node.targets[0], node.value.op, node.value.right)
-self.__error(
+self.__error(node, "Y-181", unparse(newNode), unparse(node))
-node.lineno - 1,
-node.col_offset,
-"Y-181",
-unparse(newNode),
-unparse(node),
-)
 def __check182(self, node):
 """
 Private method to check for calls of type 'super()' that could
 be shortened to 'super()'.
 and len(node.args) == 2
 and all(isinstance(arg, ast.Name) for arg in node.args)
 and node.args[0].id == self.__classDefinitionStack[-1]
 and node.args[1].id == "self"
 ):
-self.__error(node.lineno - 1, node.col_offset, "Y-182", unparse(node))
+self.__error(node, "Y-182", unparse(node))
 def __check201(self, node):
 """
 Private method to check for calls where an unary 'not' is used for
 an unequality.
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-201", left, right)
+self.__error(node, "Y-201", left, right)
 def __check202(self, node):
 """
 Private method to check for calls where an unary 'not' is used for
 an equality.
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-202", left, right)
+self.__error(node, "Y-202", left, right)
 def __check203(self, node):
 """
 Private method to check for calls where an unary 'not' is used for
 an in-check.
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-203", left, right)
+self.__error(node, "Y-203", left, right)
 def __check204(self, node):
 """
 Private method to check for calls of the type "not (a < b)".
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-204", left, right)
+self.__error(node, "Y-204", left, right)
 def __check205(self, node):
 """
 Private method to check for calls of the type "not (a <= b)".
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-205", left, right)
+self.__error(node, "Y-205", left, right)
 def __check206(self, node):
 """
 Private method to check for calls of the type "not (a > b)".
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-206", left, right)
+self.__error(node, "Y-206", left, right)
 def __check207(self, node):
 """
 Private method to check for calls of the type "not (a >= b)".
 and self.__isExceptionCheck(node.parent)
 ):
 comparison = node.operand
 left = unparse(comparison.left)
 right = unparse(comparison.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-207", left, right)
+self.__error(node, "Y-207", left, right)
 def __check208(self, node):
 """
 Private method to check for calls of the type "not (not a)".
 isinstance(node.op, ast.Not)
 and isinstance(node.operand, ast.UnaryOp)
 and isinstance(node.operand.op, ast.Not)
 ):
 var = unparse(node.operand.operand)
-self.__error(node.lineno - 1, node.col_offset, "Y-208", var)
+self.__error(node, "Y-208", var)
 def __check211(self, node):
 """
 Private method to check for calls of the type "True if a else False".
 cond = unparse(node.test)
 if isinstance(node.test, ast.Name):
 newCond = "bool({0})".format(cond)
 else:
 newCond = cond
-self.__error(node.lineno - 1, node.col_offset, "Y-211", cond, newCond)
+self.__error(node, "Y-211", cond, newCond)
 def __check212(self, node):
 """
 Private method to check for calls of the type "False if a else True".
 else:
 if len(node.test.ops) == 1:
 newCond = unparse(self.__negateTest(node.test))
 else:
 newCond = "not ({0})".format(cond)
-self.__error(node.lineno - 1, node.col_offset, "Y-212", cond, newCond)
+self.__error(node, "Y-212", cond, newCond)
 def __check213(self, node):
 """
 Private method to check for calls of the type "b if not a else a".
 and isinstance(node.test.op, ast.Not)
 and self.__isSameExpression(node.test.operand, node.orelse)
 ):
 a = unparse(node.test.operand)
 b = unparse(node.body)
-self.__error(node.lineno - 1, node.col_offset, "Y-213", a, b)
+self.__error(node, "Y-213", a, b)
 def __check221(self, node):
 """
 Private method to check for calls of the type "a and not a".
 nonNegatedExpressions.append(exp)
 for negatedExpression in negatedExpressions:
 for nonNegatedExpression in nonNegatedExpressions:
 if self.__isSameExpression(negatedExpression, nonNegatedExpression):
 negExp = unparse(negatedExpression)
-self.__error(node.lineno - 1, node.col_offset, "Y-221", negExp)
+self.__error(node, "Y-221", negExp)
 def __check222(self, node):
 """
 Private method to check for calls of the type "a or not a".
 nonNegatedExpressions.append(exp)
 for negatedExpression in negatedExpressions:
 for nonNegatedExpression in nonNegatedExpressions:
 if self.__isSameExpression(negatedExpression, nonNegatedExpression):
 negExp = unparse(negatedExpression)
-self.__error(node.lineno - 1, node.col_offset, "Y-222", negExp)
+self.__error(node, "Y-222", negExp)
 def __check223(self, node):
 """
 Private method to check for calls of the type "... or True".
 """
 # a or True
 if isinstance(node.op, ast.Or):
 for exp in node.values:
 if isinstance(exp, ast.Constant) and exp.value is True:
-self.__error(node.lineno - 1, node.col_offset, "Y-223")
+self.__error(node, "Y-223")
 def __check224(self, node):
 """
 Private method to check for calls of the type "... and False".
 """
 # a and False
 if isinstance(node.op, ast.And):
 for exp in node.values:
 if isinstance(exp, ast.Constant) and exp.value is False:
-self.__error(node.lineno - 1, node.col_offset, "Y-224")
+self.__error(node, "Y-224")
 def __check301(self, node):
 """
 Private method to check for Yoda conditions.
 node.left.value, str
 )
 if isStr:
 left = f"'{left}'"
 right = unparse(node.comparators[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-301", left, right)
+self.__error(node, "Y-301", left, right)
 def __check401(self, node):
 """
 Private method to check for bare boolean function arguments.
 )
 isException = isinstance(node.func, ast.Attribute) and node.func.attr in ["get"]
 if hasBareBool and not isException:
-self.__error(node.lineno - 1, node.col_offset, "Y-401")
+self.__error(node, "Y-401")
 def __check402(self, node):
 """
 Private method to check for bare numeric function arguments.
 isException = isException or (
 isinstance(node.func, ast.Attribute) and node.func.attr in ("get", "insert")
 )
 if hasBareNumeric and not isException:
-self.__error(node.lineno - 1, node.col_offset, "Y-402")
+self.__error(node, "Y-402")
 def __check411(self, node):
 """
 Private method to check for nested f-strings.
 if fieldName == "values":
 for innerNode in value:
 self.__check411(innerNode)
 if fieldName == "value" and isinstance(value, ast.JoinedStr):
-self.__error(node.lineno - 1, node.col_offset, "Y-411")
+self.__error(node, "Y-411")
 def __check901(self, node):
 """
 Private method to check for unnecessary bool conversion.
 and len(node.args) == 1
 and isinstance(node.args[0], ast.Compare)
 ):
 actual = unparse(node)
 expected = unparse(node.args[0])
-self.__error(node.lineno - 1, node.col_offset, "Y-901", expected, actual)
+self.__error(node, "Y-901", expected, actual)
 def __check904(self, node):
 """
 Private method to check for dictionary initialization.
 and isinstance(node.targets[0], ast.Name)
 and n2.targets[0].value.id == node.targets[0].id
 ):
 dictName = unparse(node.targets[0])
 if not self.__expressionUsesVariable(n2.value, dictName):
-self.__error(node.lineno - 1, node.col_offset, "Y-904", dictName)
+self.__error(node, "Y-904", dictName)
 def __check905(self, node):
 """
 Private method to check for list initialization by splitting a string.
 ):
 value = node.func.value.value
 expected = json.dumps(value.split())
 actual = unparse(node.func.value) + ".split()"
-self.__error(node.lineno - 1, node.col_offset, "Y-905", expected, actual)
+self.__error(node, "Y-905", expected, actual)
 def __check906(self, node):
 """
 Private method to check for unnecessary nesting of os.path.join().
 ):
 names = getOsPathJoinArgs(node)
 actual = unparse(node)
 expected = "os.path.join({0})".format(", ".join(names))
-self.__error(node.lineno - 1, node.col_offset, "Y-906", expected, actual)
+self.__error(node, "Y-906", expected, actual)
 def __check907(self, node):
 """
 Private method to check for Union type annotation with None.
 else:
 others.append(elt)
 if len(others) == 1 and hasNone:
 type_ = unparse(others[0])
-self.__error(
+self.__error(node, "Y-907", type_, unparse(node))
-node.lineno - 1, node.col_offset, "Y-907", type_, unparse(node)
-)
 def __check909(self, node):
 """
 Private method to check for reflexive assignments.
 for target in node.targets:
 names.append(unparse(target))
 if len(names) != len(set(names)) and not isinstance(node.parent, ast.ClassDef):
 srccode = unparse(node)
-self.__error(node.lineno - 1, node.col_offset, "Y-909", srccode)
+self.__error(node, "Y-909", srccode)
 def __check910(self, node):
 """
 Private method to check for uses of 'dict.get(key, None)'.
 actual = unparse(node)
 func = unparse(node.func)
 key = unparse(node.args[0])
 expected = f"{func}({key})"
-self.__error(node.lineno - 1, node.col_offset, "Y-910", expected, actual)
+self.__error(node, "Y-910", expected, actual)
 def __check911(self, node):
 """
 Private method to check for the expression "zip(_.keys(), _.values())".
 and isinstance(secondArg.func, ast.Attribute)
 and isinstance(secondArg.func.value, ast.Name)
 and secondArg.func.attr == "values"
 and firstArg.func.value.id == secondArg.func.value.id
 ):
-self.__error(
+self.__error(node, "Y-911", firstArg.func.value.id)
-node.lineno - 1, node.col_offset, "Y-911", firstArg.func.value.id
-)
 #
 # eflag: noqa = M-891

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py