NoIssue - Detect redundant comparisons

flake8-eyeo/flake8_eyeo.py

 # This file is part of Adblock Plus <https://adblockplus.org/>,
 # Copyright (C) 2006-present eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ skipping 269 matching lines @@
                                            'unordered data'))
 
             consts_first = single and not membership or symmetric
             if consts_first and is_const(left) and not is_const(right):
                 self.errors.append((left, 'A103 yoda condition'))
 
             left = right
 
         self.generic_visit(node)
 
+    def visit_BoolOp(self, node):
+        if isinstance(node.op, ast.Or):
+            left = node.values[0]
+            right = node.values[1]

[Sebastian Noack, 2017/12/10 23:19:57]

What if there is another condition in between? E.g: x == 1 or y or x == 2

+            if (isinstance(left, ast.Compare) and
+                    isinstance(right, ast.Compare)):
+                if (isinstance(left.ops[0], ast.Eq) and
+                   isinstance(left.ops[0], ast.Eq) or

[Sebastian Noack, 2017/12/10 23:19:57]

This expression is the same as the left-hand side of the and-operator.

+                    (isinstance(left.ops[0], ast.NotEq) and
+                        isinstance(left.ops[0], ast.NotEq))):
+                    value1names = []
+                    value2names = []
+                    # Gather variable names from the left comparison
+                    if isinstance(left.left, ast.Name):

[Sebastian Noack, 2017/12/10 23:19:57]

What if it is an Attribute node? E.g: x.a == 1 or x.a == 2

+                        value1names.append(left.left.id)
+                    if isinstance(left.comparators[0], ast.Name):
+                        value1names.append(left.comparators[0].id)
+                    # Gather variable names from the right comparison
+                    if isinstance(right.left, ast.Name):
+                        value2names.append(right.left.id)
+                    if isinstance(right.comparators[0], ast.Name):
+                        value2names.append(right.comparators[0].id)
+                    # Check for duplicates
+                    for i in value1names:
+                        if i in value2names:
+                            self.errors.append((node, 'A208 `{} == x or {} == '
+                                                      'y` should be `{} in {{x'
+                                                      ', y}}`'.format(i, i,
+                                                                      i)))
+
     def _check_deprecated(self, node, name):
         substitute = DISCOURAGED_APIS.get(name)
         if substitute:
             self.errors.append((node, 'A301 use {}() instead of '
                                       '{}()'.format(substitute, name)))
 
     def visit_Call(self, node):
         func = get_identifier(node.func)
         arg = next(iter(node.args), None)
         redundant_literal = False
@@ skipping 84 matching lines @@
 def check_quotes(logical_line, tokens, previous_logical, checker_state):
     first_token = True
 
     token_strings = [t[1] for t in tokens]
     future_import = token_strings[:3] == ['from', '__future__', 'import']
 
     if future_import and 'unicode_literals' in token_strings:
         checker_state['has_unicode_literals'] = True
 
     for kind, token, start, end, _ in tokens:
-        if kind == tokenize.INDENT or kind == tokenize.DEDENT:
+        if kind in {tokenize.INDENT, tokenize.DEDENT}:
             continue
 
         if kind == tokenize.STRING:
             match = re.search(r'^([rub]*)([\'"]{1,3})(.*)\2$',
                               token, re.IGNORECASE | re.DOTALL)
             prefixes, quote, text = match.groups()
             prefixes = prefixes.lower()
 
             if 'u' in prefixes:
                 yield (start, 'A112 use "from __future__ import '
@@ skipping 86 matching lines @@
             if is_tuple or is_nested_op or is_compare_in_assign:
                 continue
 
             yield (pos[0], pos[1], 'A111 redundant parenthesis', None)
 
 
 for checker in [check_ast, check_non_default_encoding,
                 check_quotes, check_redundant_parenthesis]:
     checker.name = 'eyeo'
     checker.version = __version__