Closes #861

Author: sobolevn

CHANGELOG.md

@@ -36,6 +36,7 @@ We used to have incremental versioning before `0.1.0`.
 - Forbids to use consecutive `yield` expressions
 - Enforces to use `.items()` in loops
 - Enforces using `.get()` over `key in dict` checks
+- Forbids to use and declare `float` keys in arrays and dictionaries
 
 ### Bugfixes
 
@@ -52,6 +53,7 @@ We used to have incremental versioning before `0.1.0`.
 - Fixes that `//` was not recognised as a math operation
 - Fixes false positive `BlockAndLocalOverlapViolation` on annotations without value assign
 - Fixes bug when `x and not x` was not detected as the similar conditions by `WPS408`
+- Fixed that `1.0` and `0.1` were treated as magic numbers
 
 ### Misc
 

tests/fixtures/noqa.py

@@ -617,3 +617,4 @@ def consecutive_yields():
 
 if 'key' in some_dict:
     print(some_dict['key'])  # noqa: WPS529
+    print(other_dict[1.0])  # noqa: WPS449

tests/test_checker/test_noqa.py

@@ -182,6 +182,7 @@
     'WPS446': 1,
     'WPS447': 1,
     'WPS448': 1,
+    'WPS449': 1,
 
     'WPS500': 1,
     'WPS501': 1,

tests/test_visitors/test_ast/test_builtins/test_collection_hashes/test_float_keys.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from wemake_python_styleguide.violations.best_practices import (
+    FloatKeyViolation,
+)
+from wemake_python_styleguide.visitors.ast.builtins import (
+    WrongCollectionVisitor,
+)
+
+dict_template1 = '{{ {0}: 1 }}'
+dict_template2 = '{{ {0}: {0} }}'
+dict_template3 = '{{ {0}: 1, **kwargs }}'
+dict_template4 = '{{ {0}: 1, other: value }}'
+
+
+@pytest.mark.parametrize('code', [
+    dict_template1,
+    dict_template2,
+    dict_template3,
+    dict_template4,
+])
+@pytest.mark.parametrize('element', [
+    '1.0',
+    '-0.3',
+    '+0.0',
+])
+def test_dict_with_float_key(
+    assert_errors,
+    parse_ast_tree,
+    code,
+    element,
+    default_options,
+):
+    """Testing that float keys are not allowed."""
+    tree = parse_ast_tree(code.format(element, element))
+
+    visitor = WrongCollectionVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [FloatKeyViolation])
+
+
+@pytest.mark.parametrize('code', [
+    dict_template1,
+    dict_template2,
+    dict_template3,
+    dict_template4,
+])
+@pytest.mark.parametrize('element', [
+    '1',
+    '"-0.3"',
+    '0 + 0.1',
+    '0 - 1.0',
+    '1 / 3',
+    '1 // 3',
+    'call()',
+    'name',
+    'attr.some',
+    'done[key]',
+])
+def test_dict_with_regular(
+    assert_errors,
+    parse_ast_tree,
+    code,
+    element,
+    default_options,
+):
+    """Testing that regular keys are allowed."""
+    tree = parse_ast_tree(code.format(element, element))
+
+    visitor = WrongCollectionVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])

tests/test_visitors/test_ast/test_builtins/test_collection_hashes/test_hash_elements.py

@@ -64,7 +64,7 @@ def test_collection_with_impure(
 @pytest.mark.parametrize('element', [
     '1',
     '-1',
-    '0.5',
+    '1 - b',
     'variable_name',
     'True',
     'None',
@@ -96,7 +96,6 @@ def test_set_with_pure_unique(
 @pytest.mark.parametrize('element', [
     '1',
     '-1',
-    '--0.5',
     'variable_name',
     'True',
     'None',

tests/test_visitors/test_ast/test_builtins/test_numbers/test_magic_numbers.py

@@ -87,7 +87,9 @@ def method(self):
     -3.5,
     0,
     0.0,
+    0.1,
     0.5,
+    -1.0,
     8.3,
     10,
     765,

tests/test_visitors/test_ast/test_subscripts/test_float_key_usage.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from wemake_python_styleguide.violations.best_practices import (
+    FloatKeyViolation,
+)
+from wemake_python_styleguide.visitors.ast.subscripts import CorrectKeyVisitor
+
+usage_template = 'some_dict[{0}]'
+
+
+@pytest.mark.parametrize('expression', [
+    '1.0',
+    '-0.0',
+    '+3.5',
+])
+def test_float_key_usage(
+    assert_errors,
+    parse_ast_tree,
+    expression,
+    default_options,
+):
+    """Testing that redundant subscripts are forbidden."""
+    tree = parse_ast_tree(usage_template.format(expression))
+
+    visitor = CorrectKeyVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [FloatKeyViolation])
+
+
+@pytest.mark.parametrize('expression', [
+    '5',
+    'name',
+    'call()',
+    'name.attr',
+    'name[sub]',
+    '...',
+    '"str"',
+    'b""',
+    '3j',
+    '5 + 0.1',
+    '3 / 2',
+])
+def test_correct_subscripts(
+    assert_errors,
+    parse_ast_tree,
+    expression,
+    default_options,
+):
+    """Testing that non-redundant subscripts are allowed."""
+    tree = parse_ast_tree(usage_template.format(expression))
+
+    visitor = CorrectKeyVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])

tests/test_visitors/test_ast/test_subscripts/test_redundant_subscripts.py

@@ -7,17 +7,17 @@
 )
 from wemake_python_styleguide.visitors.ast.subscripts import SubscriptVisitor
 
-usage_template = 'constant{0}'
+usage_template = 'constant[{0}]'
 
 
 @pytest.mark.parametrize('expression', [
-    '[0:7]',
-    '[0:7:1]',
-    '[None:7]',
-    '[3:None]',
-    '[3:None:2]',
-    '[3:7:None]',
-    '[3:7:1]',
+    '0:7',
+    '0:7:1',
+    'None:7',
+    '3:None',
+    '3:None:2',
+    '3:7:None',
+    '3:7:1',
 ])
 def test_redundant_subscript(
     assert_errors,
@@ -35,19 +35,19 @@ def test_redundant_subscript(
 
 
 @pytest.mark.parametrize('expression', [
-    '[5]',
-    '[3:7]',
-    '[3:7:2]',
-    '[3:]',
-    '[:7]',
-    '[3::2]',
-    '[3:7:]',
-    '[:7:2]',
-    '[3::]',
-    '[:7:]',
-    '[::2]',
-    '[:]',
-    '[::]',
+    '5',
+    '3:7',
+    '3:7:2',
+    '3:',
+    ':7',
+    '3::2',
+    '3:7:',
+    ':7:2',
+    '3::',
+    ':7:',
+    '::2',
+    ':',
+    '::',
 ])
 def test_correct_subscripts(
     assert_errors,

wemake_python_styleguide/constants.py

@@ -291,7 +291,9 @@
 #: Common numbers that are allowed to be used without being called "magic".
 MAGIC_NUMBERS_WHITELIST: Final = frozenset((
     0,  # both int and float
+    0.1,
     0.5,
+    1.0,
     100,
     1000,
     1024,  # bytes

wemake_python_styleguide/logic/safe_eval.py

@@ -29,7 +29,7 @@ def _convert_num(node: AST):
             return node.value
     elif isinstance(node, Num):
         return node.n
-    elif isinstance(node, Name):
+    elif isinstance(node, Name):  # That's what is modified from the original
         # We return string names as is, see how we return strings:
         return node.id
     raise ValueError('malformed node or string: {0!r}'.format(node))

wemake_python_styleguide/presets/types/tree.py

@@ -103,6 +103,7 @@
 
     subscripts.SubscriptVisitor,
     subscripts.ImplicitDictGetVisitor,
+    subscripts.CorrectKeyVisitor,
 
     # Complexity:
     *complexity.PRESET,

wemake_python_styleguide/violations/best_practices.py

@@ -68,6 +68,7 @@
    ApproximateConstantViolation
    StringConstantRedefinedViolation
    IncorrectExceptOrderViolation
+   FloatKeyViolation
 
 Best practices
 --------------
@@ -121,6 +122,7 @@
 .. autoclass:: ApproximateConstantViolation
 .. autoclass:: StringConstantRedefinedViolation
 .. autoclass:: IncorrectExceptOrderViolation
+.. autoclass:: FloatKeyViolation
 
 """
 
@@ -1867,9 +1869,11 @@ class StringConstantRedefinedViolation(ASTViolation):
 @final
 class IncorrectExceptOrderViolation(ASTViolation):
     """
-    Forbids the use incorrect order of ``except``.
+    Forbids the use of incorrect order of ``except``.
 
     Note, we only check for built-in exceptions.
+    Because we cannot statically identify
+    the inheritance order of custom ones.
 
     Reasoning:
         Using incorrect order of exceptions is error-prone, since
@@ -1905,3 +1909,35 @@ class IncorrectExceptOrderViolation(ASTViolation):
 
     error_template = 'Found incorrect exception order'
     code = 448
+
+
+@final
+class FloatKeyViolation(ASTViolation):
+    """
+    Forbids to define and use ``float`` keys.
+
+    Reasoning:
+        ``float`` is a very ugly data type.
+        It has a lot of "precision" errors.
+        When we use ``float`` as keys we can hit this wall.
+        We also cannot use ``float`` keys with lists by design.
+
+    Solution:
+        Use other data types: integers, decimals, or use fuzzy logic.
+
+    Example::
+
+        # Correct:
+        some = {1: 'a'}
+        some[1]
+
+        # Wrong:
+        some = {1.0: 'a'}
+        some[1.0]
+
+    .. versionadded:: 0.13.0
+
+    """
+
+    error_template = 'Found float used as a key'
+    code = 449

wemake_python_styleguide/visitors/ast/builtins.py

@@ -30,6 +30,7 @@
 from wemake_python_styleguide.violations import consistency
 from wemake_python_styleguide.violations.best_practices import (
     ApproximateConstantViolation,
+    FloatKeyViolation,
     MagicNumberViolation,
     MultipleAssignmentsViolation,
     NonUniqueItemsInHashViolation,
@@ -290,10 +291,12 @@ def visit_Dict(self, node: ast.Dict) -> None:
         Raises:
             NonUniqueItemsInHashViolation
             UnhashableTypeInHashViolation
+            FloatKeyViolation
 
         """
         self._check_set_elements(node, node.keys)
         self._check_unhashable_elements(node.keys)
+        self._check_float_keys(node.keys)
         self.generic_visit(node)
 
     def _check_unhashable_elements(
@@ -337,6 +340,19 @@ def _check_set_elements(
                 )
         self._report_set_elements(node, elements, element_values)
 
+    def _check_float_keys(self, keys: Sequence[Optional[ast.AST]]) -> None:
+        for dict_key in keys:
+            if dict_key is None:
+                continue
+
+            real_key = unwrap_unary_node(dict_key)
+            is_float_key = (
+                isinstance(real_key, ast.Num) and
+                isinstance(real_key.n, float)
+            )
+            if is_float_key:
+                self.add_violation(FloatKeyViolation(dict_key))
+
     def _report_set_elements(
         self,
         node: Union[ast.Set, ast.Dict],