Check for duplicate dictionary keys

Author: Madda

pyflakes/checker.py

@@ -127,6 +127,31 @@ class Definition(Binding):
     """
 
 
+class UnhandledKeyType(object):
+    """
+    A dictionary key of a type that we cannot or do not check for duplicates.
+    """
+
+
+class VariableKey(object):
+    """
+    A dictionary key which is a variable.
+
+    @ivar item: The variable AST object.
+    """
+    def __init__(self, item):
+        self.name = item.id
+
+    def __eq__(self, compare):
+        return (
+            compare.__class__ == self.__class__
+            and compare.name == self.name
+        )
+
+    def __hash__(self):
+        return hash(self.name)
+
+
 class Importation(Definition):
     """
     A binding created by an import statement.
@@ -849,7 +874,7 @@ def ignore(self, node):
     PASS = ignore
 
     # "expr" type nodes
-    BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = \
+    BOOLOP = BINOP = UNARYOP = IFEXP = SET = \
         COMPARE = CALL = REPR = ATTRIBUTE = SUBSCRIPT = \
         STARRED = NAMECONSTANT = handleChildren
 
@@ -870,6 +895,33 @@ def ignore(self, node):
     # additional node types
     COMPREHENSION = KEYWORD = FORMATTEDVALUE = handleChildren
 
+    def DICT(self, node):
+        keys = node.keys
+        keys = [self.convert_to_value(key) for key in keys]
+        for key in set(keys):
+            if keys.count(key) > 1:
+                if isinstance(key, VariableKey):
+                    self.report(messages.DuplicateVariableDictionaryKey,
+                                node, key.name)
+                else:
+                    self.report(messages.DuplicateDictionaryKey, node, key)
+        self.handleChildren(node)
+
+    def convert_to_value(self, item):
+        if isinstance(item, ast.Str):
+            return item.s
+        elif isinstance(item, ast.Tuple):
+            return tuple(self.convert_to_value(i) for i in item.elts)
+        elif isinstance(item, ast.Num):
+            return item.n
+        elif isinstance(item, ast.Name):
+            return VariableKey(item=item)
+        elif (not PY33) and isinstance(item, ast.NameConstant):
+            # None, True, False are nameconstants in python3, but names in 2
+            return item.value
+        else:
+            return UnhandledKeyType()
+
     def ASSERT(self, node):
         if isinstance(node.test, ast.Tuple) and node.test.elts != []:
             self.report(messages.AssertTuple, node)

pyflakes/messages.py

@@ -116,6 +116,22 @@ def __init__(self, filename, loc, name):
         self.message_args = (name,)
 
 
+class DuplicateDictionaryKey(Message):
+    message = 'dictionary key %s duplicated'
+
+    def __init__(self, filename, loc, key):
+        Message.__init__(self, filename, loc)
+        self.message_args = (key,)
+
+
+class DuplicateVariableDictionaryKey(Message):
+    message = 'dictionary key variable %s duplicated'
+
+    def __init__(self, filename, loc, key):
+        Message.__init__(self, filename, loc)
+        self.message_args = (key,)
+
+
 class LateFutureImport(Message):
     message = 'from __future__ imports must occur at the beginning of the file'
 

pyflakes/test/test_other.py

@@ -13,6 +13,97 @@ class Test(TestCase):
     def test_duplicateArgs(self):
         self.flakes('def fu(bar, bar): pass', m.DuplicateArgument)
 
+    def test_duplicate_keys(self):
+        self.flakes("{'yes': 1, 'yes': 1}", m.DuplicateDictionaryKey)
+
+    def test_multiple_duplicate_keys(self):
+        self.flakes(
+            "{'yes': 1, 'yes': 1, 'no': 2, 'no': 3}",
+            m.DuplicateDictionaryKey, m.DuplicateDictionaryKey)
+
+    def test_duplicate_keys_in_function(self):
+        self.flakes('''
+        def f(thing):
+            pass
+        f({'yes': 1, 'yes': 4})
+        ''', m.DuplicateDictionaryKey)
+
+    def test_duplicate_keys_in_lambda(self):
+        self.flakes("lambda x: {(0,1): 1, (0,1): 1}",
+                    m.DuplicateDictionaryKey)
+
+    def test_duplicate_keys_tuples(self):
+        self.flakes("{(0,1): 1, (0,1): 1}", m.DuplicateDictionaryKey)
+
+    def test_duplicate_keys_ints(self):
+        self.flakes("{1: 1, 1: 1}", m.DuplicateDictionaryKey)
+
+    def test_duplicate_keys_bools(self):
+        if version_info < (3, 4):
+            expected = m.DuplicateVariableDictionaryKey
+        else:
+            expected = m.DuplicateDictionaryKey
+        self.flakes("{True: 1, True: 1}", expected)
+
+    def test_duplicate_keys_none(self):
+        if version_info < (3, 4):
+            expected = m.DuplicateVariableDictionaryKey
+        else:
+            expected = m.DuplicateDictionaryKey
+        self.flakes("{None: 1, None: 1}", expected)
+
+    def test_duplicate_variable_keys(self):
+        self.flakes('''
+        a = 1
+        {a: 2, a: 3}
+        ''', m.DuplicateVariableDictionaryKey)
+
+    def test_duplicate_key_float_and_int(self):
+        self.flakes('''
+        {1: 1, 1.0: 1}
+        ''', m.DuplicateDictionaryKey)
+
+    def test_no_duplicate_key_errors(self):
+        self.flakes('''
+        {'yes': 1, 'no': 1}
+        ''')
+
+    def test_no_duplicate_key_errors_func_call(self):
+        self.flakes('''
+        def test(thing):
+            pass
+        test({True: 1, None: 2, False: 1})
+        ''')
+
+    def test_no_duplicate_key_errors_bool_or_none(self):
+        self.flakes("{True: 1, None: 2, False: 1}")
+
+    def test_no_duplicate_key_errors_ints(self):
+        self.flakes('''
+        {1: 1, 2: 1}
+        ''')
+
+    def test_no_duplicate_key_errors_vars(self):
+        self.flakes('''
+        test = 'yes'
+        rest = 'yes'
+        {test: 1, rest: 2}
+        ''')
+
+    def test_no_duplicate_key_errors_tuples(self):
+        self.flakes('''
+        {(0,1): 1, (0,2): 1}
+        ''')
+
+    def test_no_duplicate_key_errors_instance_attributes(self):
+        self.flakes('''
+        class Test():
+            pass
+        f = Test()
+        f.a = 1
+        {f.a: 1, f.a: 1}
+        ''')
+
     def test_localReferencedBeforeAssignment(self):
         self.flakes('''
         a = 1