add 'max-returns' linter check, closes #4

Author: Scony

gdtoolkit/common/ast.py

@@ -5,6 +5,43 @@
 from .utils import find_name_token_among_children, find_tree_among_children
 
 
+# pylint: disable=too-few-public-methods
+class Statement:
+    """Abstract representation of statement"""
+
+    def __init__(self, node: Tree):
+        self.lark_node = node
+        self.kind = node.data
+        self.sub_statements = []  # type: List[Statement]
+        self.all_sub_statements = []  # type: List[Statement]
+
+        self._load_sub_statements()
+
+    def _load_sub_statements(self):
+        if self.kind == "class_def":
+            pass
+        elif self.kind == "property_body_def":
+            pass
+        elif self.kind in ["func_def", "static_func_def"]:
+            self.sub_statements = [Statement(n) for n in self.lark_node.children[1:]]
+        elif self.kind == "if_stmt":
+            for branch in self.lark_node.children:
+                if branch.data in ["if_branch", "elif_branch"]:
+                    self.sub_statements += [Statement(n) for n in branch.children[1:]]
+                else:
+                    self.sub_statements += [Statement(n) for n in branch.children]
+        elif self.kind == "while_stmt":
+            pass
+        elif self.kind == "for_stmt":
+            pass
+        elif self.kind == "match_stmt":
+            pass
+        for sub_statement in self.sub_statements:
+            self.all_sub_statements += [
+                sub_statement
+            ] + sub_statement.all_sub_statements
+
+
 # pylint: disable=too-few-public-methods
 class Parameter:
     """Abstract representation of function parameter"""
@@ -13,6 +50,7 @@ def __init__(self, node: Tree):
         self.name = node.children[0].value
 
 
+# TODO: inherit from statement
 # pylint: disable=too-few-public-methods
 class Function:
     """Abstract representation of function"""
@@ -34,6 +72,8 @@ def _load_data_from_func_def(self, func_def: Tree) -> None:
             for c in func_args.children  # type: ignore
             if c.data != "trailing_comma"
         ]
+        slf = Statement(self.lark_node)
+        self.all_statements = [slf] + slf.all_sub_statements
 
 
 # pylint: disable=too-few-public-methods

gdtoolkit/linter/__init__.py

@@ -73,7 +73,7 @@
         # useless-super-delegation
         # design checks
         # max-locals
-        # max-returns
+        "max-returns": 6,
         # max-branches
         # max-statements
         # max-attributes

gdtoolkit/linter/design_checks.py

@@ -17,6 +17,10 @@ def lint(parse_tree: Tree, config: MappingProxyType) -> List[Problem]:
             "max-public-methods",
             partial(_max_public_methods_check, config["max-public-methods"]),
         ),
+        (
+            "max-returns",
+            partial(_max_returns_check, config["max-returns"]),
+        ),
         (
             "function-arguments-number",
             partial(_function_args_num_check, config["function-arguments-number"]),
@@ -33,13 +37,12 @@ def lint(parse_tree: Tree, config: MappingProxyType) -> List[Problem]:
 def _function_args_num_check(threshold: int, ast: AbstractSyntaxTree) -> List[Problem]:
     problems = []
     for function in ast.all_functions:
-        func_name = function.name
         if len(function.parameters) > threshold:
             problems.append(
                 Problem(
                     name="function-arguments-number",
                     description='Function "{}" has more than {} arguments'.format(
-                        func_name, threshold
+                        function.name, threshold
                     ),
                     line=function.lark_node.line,
                     column=function.lark_node.column,
@@ -71,3 +74,25 @@ def _max_public_methods_check(threshold: int, ast: AbstractSyntaxTree) -> List[P
                 )
             )
     return problems
+
+
+def _max_returns_check(threshold: int, ast: AbstractSyntaxTree) -> List[Problem]:
+    problems = []
+    for function in ast.all_functions:
+        returns = [
+            statement
+            for statement in function.all_statements
+            if statement.kind == "return_stmt"
+        ]
+        if len(returns) > threshold:
+            problems.append(
+                Problem(
+                    name="max-returns",
+                    description='Function "{}" has more than {} arguments'.format(
+                        function.name, threshold
+                    ),
+                    line=returns[-1].lark_node.line,
+                    column=returns[-1].lark_node.column,
+                )
+            )
+    return problems

tests/linter/test_design_checks.py

@@ -141,3 +141,75 @@ def test_max_public_methods_ok(code):
 ])
 def test_max_public_methods_nok(code):
     simple_nok_check(code, 'max-public-methods', line=1)
+
+
+@pytest.mark.parametrize('code', [
+"""
+func foo():
+    if 1 > 2:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+""",
+"""
+func foo():
+    if 1 > 2:
+        if 1:
+            if 1:
+                if 1:
+                    return 1
+                return 1
+            return 1
+        elif 1:
+            return 1
+        return 1
+""",
+])
+def test_max_returns_ok(code):
+    simple_ok_check(code, disable=["no-elif-return"])
+
+
+@pytest.mark.parametrize('code', [
+"""
+func foo():
+    if 1 > 2:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    elif 1:
+        return 1
+    return 1
+""",
+"""
+func foo():
+    if 1 > 2:
+        if 1:
+            if 1:
+                if 1:
+                    return 1
+                return 1
+            return 1
+        elif 1:
+            return 1
+        return 1
+        return 1
+
+    return 1
+""",
+])
+def test_max_returns_nok(code):
+    simple_nok_check(code, 'max-returns', line=15, disable=['no-elif-return'])