refactor: Separate condition categories in language readers for improved structure

This commit refactors the condition handling in the CodeReader and its subclasses by introducing distinct sets for control flow keywords, logical operators, case keywords, and ternary operators. The changes enhance clarity and maintain backward compatibility by allowing subclasses to define their own conditions while utilizing a new structured approach. Additionally, the LizardExtension is updated to remove logical operators from conditions using the new semantic structure.

Author: terryyin

lizard_ext/lizardnonstrict.py

@@ -9,5 +9,7 @@ class LizardExtension(object):  # pylint: disable=R0903
 
     # pylint: disable=W0221
     def __call__(self, tokens, reader):
-        reader.conditions -= set(['&&', '||', 'and', 'or'])
+        # Remove logical operators from conditions (non-strict mode)
+        # Uses semantic logical_operators instead of hardcoded list
+        reader.conditions -= reader.logical_operators
         return tokens

lizard_languages/code_reader.py

@@ -94,12 +94,45 @@ class CodeReader:
     ext = []
     languages = None
     extra_subclasses = set()
-    _conditions = {'if', 'for', 'while', '&&', '||', '?', 'catch', 'case'}
+    
+    # Separated condition categories (new structure)
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
+    
+    # Backward compatibility: old combined set
+    # If a subclass defines only _conditions, it will be used
+    _conditions = None
+
+    @classmethod
+    def _build_conditions(cls):
+        """Build combined conditions set from separated categories.
+        
+        Returns combined set of all condition types for backward compatibility
+        and default behavior.
+        """
+        return (cls._control_flow_keywords | 
+                cls._logical_operators | 
+                cls._case_keywords | 
+                cls._ternary_operators)
 
     def __init__(self, context):
         self.parallel_states = []
         self.context = context
-        self.conditions = copy(self._conditions)
+        
+        # Backward compatibility: if subclass defines _conditions, use it
+        if self.__class__._conditions is not None:
+            self.conditions = copy(self.__class__._conditions)
+        else:
+            # Use new separated structure
+            self.conditions = copy(self.__class__._build_conditions())
+        
+        # Expose individual sets for extensions to use
+        self.control_flow_keywords = copy(self.__class__._control_flow_keywords)
+        self.logical_operators = copy(self.__class__._logical_operators)
+        self.case_keywords = copy(self.__class__._case_keywords)
+        self.ternary_operators = copy(self.__class__._ternary_operators)
 
     @classmethod
     def match_filename(cls, filename):

lizard_languages/csharp.py

@@ -11,8 +11,11 @@ class CSharpReader(CLikeReader):
     ext = ['cs']
     language_names = ['csharp']
 
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', '??'])
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?', '??'}  # C# has both ?: and ?? (null-coalescing)
 
     def __init__(self, context):
         super(CSharpReader, self).__init__(context)

lizard_languages/erlang.py

@@ -13,7 +13,13 @@ class ErlangReader(CodeReader):
 
     ext = ['erl', 'hrl', 'es', 'escript']
     language_names = ['erlang']
-    _conditions = {'and', 'case', 'catch', 'if', 'not', 'or', '?', 'when'}
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'catch', 'when'}  # when is used in guards
+    _logical_operators = {'and', 'or', 'not'}
+    _case_keywords = {'case'}
+    # Note: '?' in Erlang is a macro operator, not ternary, but adds to CCN
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(ErlangReader, self).__init__(context)