Issue: #444

feat: Add support for C# expression-bodied members in CSharpStates

This commit introduces functionality to handle C# expression-bodied members (using the '=>' syntax) in the CSharpStates class. It includes methods to confirm new functions and process expression bodies until the end of the method. Additionally, new tests have been added to verify the detection and complexity calculation of expression-bodied methods, ensuring accurate representation in the function list.

Author: terryyin

lizard_languages/csharp.py

@@ -42,6 +42,22 @@ def try_new_function(self, name):
             if self.class_name and self.context.current_function:
                 self.context.current_function.name = f"{self.class_name}::{name}"
 
+    def _state_dec_to_imp(self, token):
+        """Override to handle C# expression-bodied members (=>)"""
+        if token == '=>':
+            # Expression-bodied member: confirm function and enter expression body
+            self.context.confirm_new_function()
+            self._state = self._state_expression_body
+        else:
+            super(CSharpStates, self)._state_dec_to_imp(token)
+
+    def _state_expression_body(self, token):
+        """Read the expression body until semicolon, processing tokens for complexity"""
+        if token == ';':
+            # End of expression-bodied method, finalize function and return to global state
+            self.context.end_of_function()
+            self._state = self._state_global
+
     def _state_global(self, token):
         if token in ("class", "struct", "record"):
             self.class_name = None

test/test_languages/testCsharp.py

@@ -139,3 +139,81 @@ def test_primary_constructor_vs_traditional(self):
                        "Method should have complexity of 1")
         self.assertEqual(1, constructor_func.cyclomatic_complexity,
                        "Constructor should have complexity of 1")
+
+    def test_expression_bodied_methods(self):
+        """Test that expression-bodied methods (lambda-style syntax) are detected."""
+        result = get_csharp_function_list('''
+            using System;
+
+            public class SimpleCalculator
+            {
+                public int Add(int a, int b) => a + b;
+
+                public int Subtract(int a, int b)
+                {
+                    int result = a - b;
+                    return result;
+                }
+
+                public static void Main(string[] args)
+                {
+                    var calc = new SimpleCalculator();
+                    Console.WriteLine($"Addition: {calc.Add(30, 15)}");
+                    Console.WriteLine($"Subtraction: {calc.Subtract(30, 15)}");
+                }
+            }
+        ''')
+        
+        function_names = [f.name for f in result]
+        self.assertIn("SimpleCalculator::Add", function_names,
+                     f"Expected to find 'SimpleCalculator::Add' but only found: {function_names}")
+        self.assertIn("SimpleCalculator::Subtract", function_names,
+                     f"Expected to find 'SimpleCalculator::Subtract' but only found: {function_names}")
+        self.assertIn("SimpleCalculator::Main", function_names,
+                     f"Expected to find 'SimpleCalculator::Main' but only found: {function_names}")
+        
+        self.assertEqual(3, len(result),
+                        f"Expected 3 functions but found {len(result)}: {function_names}")
+        
+        add_func = next(f for f in result if f.name == "SimpleCalculator::Add")
+        self.assertEqual(1, add_func.cyclomatic_complexity,
+                        "Expression-bodied Add method should have complexity of 1")
+
+    def test_expression_bodied_methods(self):
+        """Test that expression-bodied methods (lambda-style syntax) are detected."""
+        result = get_csharp_function_list('''
+            using System;
+
+            public class SimpleCalculator
+            {
+                public int Add(int a, int b) => a + b;
+
+                public int Subtract(int a, int b)
+                {
+                    int result = a - b;
+                    return result;
+                }
+
+                public static void Main(string[] args)
+                {
+                    var calc = new SimpleCalculator();
+                    Console.WriteLine($"Addition: {calc.Add(30, 15)}");
+                    Console.WriteLine($"Subtraction: {calc.Subtract(30, 15)}");
+                }
+            }
+        ''')
+        
+        function_names = [f.name for f in result]
+        self.assertIn("SimpleCalculator::Add", function_names,
+                     f"Expected to find 'SimpleCalculator::Add' but only found: {function_names}")
+        self.assertIn("SimpleCalculator::Subtract", function_names,
+                     f"Expected to find 'SimpleCalculator::Subtract' but only found: {function_names}")
+        self.assertIn("SimpleCalculator::Main", function_names,
+                     f"Expected to find 'SimpleCalculator::Main' but only found: {function_names}")
+        
+        self.assertEqual(3, len(result),
+                        f"Expected 3 functions but found {len(result)}: {function_names}")
+        
+        add_func = next(f for f in result if f.name == "SimpleCalculator::Add")
+        self.assertEqual(1, add_func.cyclomatic_complexity,
+                        "Expression-bodied Add method should have complexity of 1")