Implement LoopOutsider pattern

aibolit/patterns/loop_outsider/loop_outsider.py

@@ -1,7 +1,11 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2025 Aibolit
 # SPDX-License-Identifier: MIT
-from typing import List
+
+
+from typing import List, Set
+from aibolit.ast_framework import AST, ASTNodeType
 from aibolit.types_decl import LineNumber
+from aibolit.utils.ast_builder import build_ast
 
 
 class LoopOutsider:
@@ -17,4 +21,62 @@ def value(self, filename) -> List[LineNumber]:
         """
         Returns the line number of loop outsiders found in file.
         """
-        return []
+        res = []
+        ast = AST.build_from_javalang(build_ast(filename))
+        loop_types = [ASTNodeType.WHILE_STATEMENT, ASTNodeType.FOR_STATEMENT,
+                      ASTNodeType.DO_STATEMENT]
+
+        for loop_type in loop_types:
+            for loop_statement in ast.get_proxy_nodes(loop_type):
+                subtree = ast.get_subtree(loop_statement)
+                var_changes = self._find_variable_changes(subtree)
+                loop_vars_declarations = (
+                    self._find_loop_variable_declarations(subtree,
+                                                          loop_statement,
+                                                          loop_type))
+
+                # Check if affected variables are not declared in loop_vars
+                for node in var_changes:
+                    if node.member not in loop_vars_declarations:
+                        res.append(node.line)
+
+        return sorted(res)
+
+    def _find_variable_changes(self, ast: AST) -> Set:
+        """Find all variables that are modified in the code."""
+        var_changes = set()
+
+        # Find variables affected by increment/decrement operations
+        for node in ast.get_proxy_nodes(ASTNodeType.MEMBER_REFERENCE):
+            if self._variable_is_affected(node):
+                var_changes.add(node)
+
+        # Find variables affected by assignments
+        for node in ast.get_proxy_nodes(ASTNodeType.ASSIGNMENT):
+            var_changes.add(node.expressionl)
+        return var_changes
+
+    def _find_loop_variable_declarations(self, ast: AST, loop_statement,
+                                         loop_type) -> Set:
+        """Find all variable declarations within the loop scope."""
+        loop_vars_declarations = set()
+        subtree = ast.get_subtree(loop_statement)
+
+        # Find local variable declarations
+        for node in subtree.get_proxy_nodes(
+                ASTNodeType.LOCAL_VARIABLE_DECLARATION):
+            loop_vars_declarations.add(node.names[-1])
+
+        # For for-loops, also check variable declarations in the loop header
+        if loop_type == ASTNodeType.FOR_STATEMENT:
+            for node_for in subtree.get_proxy_nodes(
+                    ASTNodeType.VARIABLE_DECLARATION):
+                loop_vars_declarations.add(node_for.names[-1])
+
+        return loop_vars_declarations
+
+    def _variable_is_affected(self, node):
+        return ('--' in node.prefix_operators or '--' in
+                node.postfix_operators or
+                '++' in node.prefix_operators or '++' in
+                node.postfix_operators)

test/patterns/loop_outsider/LoopOutsiderAddAndInWhile.java

@@ -8,4 +8,4 @@ public void loopOutsiderAddAndInWhile() {
             x += 1; // here
         }
     }
-}
+}

test/patterns/loop_outsider/NoLoopOutsider.java

@@ -0,0 +1,12 @@
+// SPDX-FileCopyrightText: Copyright (c) 2019-2025 Aibolit
+// SPDX-License-Identifier: MIT
+
+public class NoLoopOutsider {
+    public void noLoopOutsider() {
+        int x = 0;
+        Integer y = 0;
+        while (true) {
+
+        }
+    }
+}

test/patterns/loop_outsider/NoLoopOutsiderFakeIncrementing.java

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Copyright (c) 2019-2025 Aibolit
+// SPDX-License-Identifier: MIT
+
+public class NoLoopOutsiderFakeIncrementing{
+    public void noLoopOutsiderFakeIncrementing() {
+        int x = 0;
+        while (true) {
+        }
+        x++;
+    }
+}

test/patterns/loop_outsider/test_loop_outsider.py

@@ -2,13 +2,11 @@
 # SPDX-License-Identifier: MIT
 
 import os
-import unittest
 from pathlib import Path
 from unittest import TestCase
 from aibolit.patterns.loop_outsider.loop_outsider import LoopOutsider
 
 
-@unittest.skip("Not implemented")
 class LoopOutsiderTestCase(TestCase):
     """
     @todo #138:30min Continue to implement loop_outsider
@@ -21,104 +19,114 @@ class LoopOutsiderTestCase(TestCase):
     def test_find_loop_outsider_assignment_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderAssignmentInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider assignment in while loop",
         )
 
     def test_find_loop_outsider_prefix_increment_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderPrefixIncrementInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with prefix increment in while loop",
         )
 
     def test_find_loop_outsider_postfix_increment_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderPostfixIncrementInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with postfix increment in while loop",
         )
 
     def test_find_loop_outsider_prefix_decrement_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderPrefixDecrementInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with prefix decrement in while loop",
         )
 
     def test_find_loop_outsider_postfix_decrement_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderPostfixDecrementInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with postfix decrement in while loop",
         )
 
     def test_find_loop_outsider_add_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderAddAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with add AND in while loop",
         )
 
     def test_find_loop_outsider_subtract_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderSubtractAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with subtract AND in while loop",
         )
 
     def test_find_loop_outsider_multiply_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderMultiplyAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with multiply AND in while loop",
         )
 
     def test_find_loop_outsider_divide_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderDivideAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with divide AND in while loop",
         )
 
     def test_find_loop_outsider_modulus_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderModulusAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with modulus AND in while loop",
         )
 
     def test_find_loop_outsider_left_shift_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderLeftShiftAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with left shift AND in while loop",
         )
 
     def test_find_loop_outsider_right_shift_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderRightShiftAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with right shift AND in while loop",
         )
 
     def test_find_loop_outsider_bitwise_and_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderBitwiseAndInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with bitwise AND in while loop",
         )
 
     def test_find_loop_outsider_bitwise_inclusive_or_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderBitwiseInclusiveOrInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with bitwise inclusive OR in while loop",
         )
 
     def test_find_loop_outsider_bitwise_exclusive_or_in_while(self):
         self.assertEqual(
             LoopOutsider().value(Path(self.dir_path, "LoopOutsiderBitwiseExclusiveOrInWhile.java")),
-            [5],
+            [8],
             "Could not find loop outsider with bitwise exclusive OR in while loop",
         )
+
+    def test_should_not_detect_loop_outsider_when_variable_never_modified_outside_loop(self):
+        self.assertEqual(LoopOutsider().value(Path(self.dir_path,
+                                                   "NoLoopOutsider.java")), [],
+                         "Found unexisted loop outsider")
+
+    def test_should_not_detect_loop_outsider_when_incrementing_outside_loop(self):
+        self.assertEqual(LoopOutsider().value(Path(self.dir_path,
+                                                   "NoLoopOutsiderFakeIncrementing.java")), [],
+                         "Found unexisted loop outsider")