Closes #862

Author: sobolevn

CHANGELOG.md

@@ -38,6 +38,7 @@ We used to have incremental versioning before `0.1.0`.
 - 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
+- Forbids to use `a[len(a) - 1]` because it is just `a[-1]`
 
 ### Bugfixes
 

tests/fixtures/noqa.py

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

tests/test_checker/test_noqa.py

@@ -214,6 +214,7 @@
     'WPS527': 1,
     'WPS528': 1,
     'WPS529': 1,
+    'WPS530': 1,
 
     'WPS600': 1,
     'WPS601': 1,

tests/test_visitors/test_ast/test_subscripts/test_implicit_negative_index.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from wemake_python_styleguide.violations.refactoring import (
+    ImplicitNegativeIndexViolation,
+)
+from wemake_python_styleguide.visitors.ast.subscripts import CorrectKeyVisitor
+
+
+@pytest.mark.parametrize('code', [
+    'some_list[len(some_list) - 1]',
+    'some_list[len(some_list) - 1.0]',
+    'some_list[len(some_list) - 5]',
+    'some_list[len(some_list) - name]',
+    'some_list[len(some_list) - call()]',
+    'some_list[len(some_list) - name.attr]',
+    'some_list[len(some_list) - name["a"]]',
+    'attr.some_list[len(attr.some_list) - 1]',
+])
+def test_implicit_negative_index(
+    assert_errors,
+    parse_ast_tree,
+    code,
+    default_options,
+):
+    """Testing that implicit negative indexes are forbidden."""
+    tree = parse_ast_tree(code)
+
+    visitor = CorrectKeyVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [ImplicitNegativeIndexViolation])
+
+
+@pytest.mark.parametrize('code', [
+    'some_list[len(other_list) - 1]',
+    'some_list[len(some_list) + 1]',
+    'some_list[len(some_list)]',
+    'some_list[sum(some_list) + 1]',
+    'some_list[len(some_list) + 1 + 2]',
+    'some_list[-1]',
+    'some_list[1]',
+    'some_list[-name]',
+    'some_list[name.attr]',
+    'some_list[call() + 1]',
+    'some_list[some[key]]',
+])
+def test_regular_len_calls(
+    assert_errors,
+    parse_ast_tree,
+    code,
+    default_options,
+):
+    """Testing that explicit negative calls are fine."""
+    tree = parse_ast_tree(code)
+
+    visitor = CorrectKeyVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])

wemake_python_styleguide/violations/refactoring.py

@@ -45,6 +45,7 @@
    NotATupleArgumentViolation
    ImplicitItemsIteratorViolation
    ImplicitDictGetViolation
+   ImplicitNegativeIndexViolation
 
 Refactoring opportunities
 -------------------------
@@ -79,6 +80,7 @@
 .. autoclass:: NotATupleArgumentViolation
 .. autoclass:: ImplicitItemsIteratorViolation
 .. autoclass:: ImplicitDictGetViolation
+.. autoclass:: ImplicitNegativeIndexViolation
 
 """
 
@@ -1149,3 +1151,32 @@ class ImplicitDictGetViolation(ASTViolation):
 
     error_template = 'Found implicit `.get()` dict usage'
     code = 529
+
+
+@final
+class ImplicitNegativeIndexViolation(ASTViolation):
+    """
+    Forbids to use implicit negative indexes.
+
+    Reasoning:
+        There's no need in getting the length of an iterable
+        and then having a negative offset,
+        when you can specify negative indexes in the first place.
+
+    Solution:
+        Use negative indexes.
+
+    Example::
+
+        # Correct:
+        some_list[-1]
+
+        # Wrong:
+        some_list[len(some_list) - 1]
+
+    .. versionadded:: 0.13.0
+
+    """
+
+    error_template = 'Found implicit negative index'
+    code = 530

wemake_python_styleguide/visitors/ast/subscripts.py

@@ -4,7 +4,7 @@
 
 from typing_extensions import final
 
-from wemake_python_styleguide.logic import operators, slices, source
+from wemake_python_styleguide.logic import functions, operators, slices, source
 from wemake_python_styleguide.violations import (
     best_practices,
     consistency,
@@ -113,9 +113,11 @@ def visit_Subscript(self, node: ast.Subscript) -> None:
 
         Raises:
             FloatKeyViolation
+            ImplicitNegativeIndexViolation
 
         """
         self._check_float_key(node)
+        self._check_len_call(node)
         self.generic_visit(node)
 
     def _check_float_key(self, node: ast.Subscript) -> None:
@@ -127,6 +129,29 @@ def _check_float_key(self, node: ast.Subscript) -> None:
         if is_float_key:
             self.add_violation(best_practices.FloatKeyViolation(node))
 
+    def _check_len_call(self, node: ast.Subscript) -> None:
+        is_len_call = (
+            isinstance(node.slice, ast.Index) and
+            isinstance(node.slice.value, ast.BinOp) and
+            isinstance(node.slice.value.op, ast.Sub) and
+            self._is_wrong_len(
+                node.slice.value,
+                source.node_to_string(node.value),
+            )
+        )
+
+        if is_len_call:
+            self.add_violation(
+                refactoring.ImplicitNegativeIndexViolation(node),
+            )
+
+    def _is_wrong_len(self, node: ast.BinOp, element: str) -> bool:
+        return (
+            isinstance(node.left, ast.Call) and
+            bool(functions.given_function_called(node.left, {'len'})) and
+            source.node_to_string(node.left.args[0]) == element
+        )
+
     def _is_float_key(self, node: ast.Index) -> bool:
         real_node = operators.unwrap_unary_node(node.value)
         return (