Merge pull request #385 from jmal0/354-fix-python-parameter-count

fix: Correct parameter count for python function with trailing comma and parameterized type hints

lizard.py

@@ -301,11 +301,17 @@ def unqualified_name(self):
                         " %(name)s@%(start_line)s-%(end_line)s@%(filename)s"
                         % self.__dict__)
 
-    parameter_count = property(lambda self: len(self.full_parameters))
+    parameter_count = property(lambda self: len(self.parameters))
 
     @property
     def parameters(self):
-        matches = [re.search(r'(\w+)(\s=.*)?$', f)
+        # Exclude empty tokens as parameters. These can occur in languages
+        # allowing a trailing comma on the last parameter in an function
+        # argument list.
+        # Regex matches the parameter name, then optionally:
+        # - a default value given after an '=' sign
+        # - a type annotation given after a ':'
+        matches = [re.search(r'(\w+)(\s=.*)?(\s:.*)?$', f)
                    for f in self.full_parameters]
         return [m.group(1) for m in matches if m]
 

lizard_languages/python.py

@@ -84,6 +84,8 @@ def _function(self, token):
     def _dec(self, token):
         if token == ')':
             self._state = self._state_colon
+        elif token == '[':
+            self._state = self._state_parameterized_type_annotation
         else:
             self.context.parameter(token)
             return
@@ -100,3 +102,8 @@ def _state_first_line(self, token):
         if token.startswith('"""') or token.startswith("'''"):
             self.context.add_nloc(-token.count('\n') - 1)
         self._state_global(token)
+
+    def _state_parameterized_type_annotation(self, token):
+        self.context.add_to_long_function_name(" " + token)
+        if token == ']':
+            self._state = self._dec

test/test_languages/testPython.py

@@ -149,6 +149,62 @@ def function_with_2_parameters_and_default_value(a, b=None):
         functions = get_python_function_list(inspect.getsource(namespace_df))
         self.assertEqual(2, functions[0].parameter_count)
         self.assertEqual(['a', 'b'], functions[0].parameters)
+        self.assertEqual("function_with_2_parameters_and_default_value( a , b = None )",
+                         functions[0].long_name)
+
+    def test_parameter_count_with_type_annotations(self):
+        functions = get_python_function_list('''
+            def function_with_3_parameters(a: str, b: int, c: float):
+                pass
+        ''')
+        self.assertEqual(1, len(functions))
+        self.assertEqual(3, functions[0].parameter_count)
+        self.assertEqual(['a', 'b', 'c'], functions[0].parameters)
+        self.assertEqual("function_with_3_parameters( a : str , b : int , c : float )",
+                         functions[0].long_name)
+
+    def test_parameter_count_with_type_annotation_and_default(self):
+        functions = get_python_function_list('''
+            def function_with_3_parameters(a: int = 1):
+                pass
+        ''')
+        self.assertEqual(1, len(functions))
+        self.assertEqual(1, functions[0].parameter_count)
+        self.assertEqual(['a'], functions[0].parameters)
+        self.assertEqual("function_with_3_parameters( a : int = 1 )",
+                         functions[0].long_name)
+
+    def test_parameter_count_with_parameterized_type_annotations(self):
+        functions = get_python_function_list('''
+            def function_with_parameterized_parameter(a: dict[str, tuple[int, float]]):
+                pass
+            def function_with_3_parameterized_parameters(a: dict[str, int],
+                                                         b: list[float],
+                                                         c: tuple[int, float, str]
+                                                         ):
+                pass
+                
+        ''')
+        self.assertEqual(2, len(functions))
+        self.assertEqual(1, functions[0].parameter_count)
+        self.assertEqual(['a'], functions[0].parameters)
+        self.assertEqual("function_with_parameterized_parameter( a : dict [ str , tuple [ int , float ] ] )",
+                         functions[0].long_name)
+        self.assertEqual(3, functions[1].parameter_count)
+        self.assertEqual(['a', 'b', 'c'], functions[1].parameters)
+        self.assertEqual("function_with_3_parameterized_parameters( a : dict [ str , int ] , b : list [ float ] , c : tuple [ int , float , str ] )",
+                         functions[1].long_name)
+
+    def test_parameter_count_with_trailing_comma(self):
+        functions = get_python_function_list('''
+            def foo(arg1,
+                    arg2,
+                    ):
+                # comment
+                return True
+        ''')
+        self.assertEqual(2, functions[0].parameter_count)
+        self.assertEqual(['arg1', 'arg2'], functions[0].parameters)
 
     def test_function_end(self):
         class namespace3: