refactor: Finalize condition handling updates in language readers

This commit completes the refactoring of condition handling across language readers by ensuring all conditions are categorized into distinct types: control flow keywords, logical operators, case keywords, and ternary operators. Key updates include:
- Enhanced documentation for the handling of conditions, clarifying the purpose of each category.
- Adjustments to the LizardExtension to utilize the new structured approach for logical operators.
- Minor code cleanups and improvements to maintain clarity and consistency.

These changes contribute to improved maintainability and accuracy in cyclomatic complexity calculations while preserving backward compatibility.

Author: terryyin

lizard_ext/lizardnonstrict.py

@@ -10,6 +10,5 @@ class LizardExtension(object):  # pylint: disable=R0903
     # pylint: disable=W0221
     def __call__(self, tokens, reader):
         # 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

@@ -95,22 +95,20 @@ class CodeReader:
     languages = None
     extra_subclasses = set()
 
-    # Separated condition categories (new structure)
+    # Condition categories - separate types that contribute to cyclomatic complexity
     _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
+    # For compatibility with custom readers that may define _conditions directly
     _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.
+        Returns combined set of all condition types for CCN calculation.
         """
         return (cls._control_flow_keywords | 
                 cls._logical_operators | 
@@ -121,14 +119,15 @@ def __init__(self, context):
         self.parallel_states = []
         self.context = context
 
-        # Backward compatibility: if subclass defines _conditions, use it
+        # Build combined conditions set
         if self.__class__._conditions is not None:
+            # Subclass defines _conditions directly
             self.conditions = copy(self.__class__._conditions)
         else:
-            # Use new separated structure
+            # Build from separated categories
             self.conditions = copy(self.__class__._build_conditions())
 
-        # Expose individual sets for extensions to use
+        # Expose individual categories for extensions
         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)

lizard_languages/erlang.py

@@ -20,8 +20,7 @@ class ErlangReader(CodeReader):
     _case_keywords = {'case'}
     # Note: '?' in Erlang is a macro expansion operator (e.g., ?MODULE, ?EMPTY_NODE)
     # Unlike C-style ternary, it's for compile-time macro substitution
-    # Decision: Keep it in ternary_operators for CCN counting (historical compatibility)
-    # Rationale: Macro usage can add complexity to understanding code
+    # Included in ternary_operators because macro usage adds to code complexity
     _ternary_operators = {'?'}
 
     def __init__(self, context):

lizard_languages/gdscript.py

@@ -15,8 +15,6 @@ class GDScriptReader(PythonReader):
     _logical_operators = {'&&', '||'}
     _case_keywords = {'case'}
     _ternary_operators = {'?'}
-    # Note: 'else' was in original but shouldn't add to CCN independently
-    # Fixed: Added 'elif' which was missing
 
     def __init__(self, context):
         super(GDScriptReader, self).__init__(context)

lizard_languages/r.py

@@ -16,10 +16,8 @@ class RReader(CodeReader, ScriptLanguageMixIn):
     _control_flow_keywords = {'if', 'else if', 'for', 'while', 'repeat', 'switch',
                               'tryCatch', 'try', 'ifelse'}  # ifelse is a vectorized control function
     # R has both short-circuit (&&, ||) and element-wise (&, |) operators
-    # Decision: Keep both types in logical_operators because:
-    # - Even in vectorized context, they represent conditional logic
-    # - Consistent with other languages that count all logical operators
-    # - Users can use -Enonstrict to exclude all logical operators if desired
+    # Both types count toward CCN as they represent conditional logic (vectorized or not)
+    # Users can use -Enonstrict to exclude logical operators if desired
     _logical_operators = {'&&', '||', '&', '|'}
     _case_keywords = set()
     _ternary_operators = set()

lizard_languages/st.py

@@ -27,8 +27,7 @@ class StReader(CodeReader, StCommentsMixin):
         'if', 'elsif', 'for', 'while', 'repeat',
         'IF', 'ELSIF', 'FOR', 'WHILE', 'REPEAT'
     }
-    # Decision: Add AND/OR operators (they were missing from original)
-    # ST is case-insensitive, so include both forms
+    # ST is case-insensitive, so include both lowercase and uppercase forms
     _logical_operators = {'and', 'or', 'AND', 'OR'}
     _case_keywords = {'case', 'CASE'}
     _ternary_operators = set()

lizard_languages/ttcn.py

@@ -15,7 +15,6 @@ class TTCNReader(CLikeReader):  # pylint: disable=R0903
     _logical_operators = {'and', 'or', 'xor'}
     _case_keywords = {'case'}
     _ternary_operators = set()
-    # Note: 'else' was in original but shouldn't add to CCN independently
 
     def __init__(self, context):
         super(TTCNReader, self).__init__(context)

ongoing/REFACTORING_COMPLETE.md

@@ -2,22 +2,22 @@
 
 ## Status: Production Ready
 
-All phases of the conditions refactoring have been successfully completed.
+The conditions refactoring is complete. All condition-related constructs are now properly categorized.
 
-## What Was Done
+## Current Structure
 
-Separated mixed condition concepts into 4 distinct categories across the entire Lizard codebase:
+Lizard now separates condition concepts into 4 distinct categories:
 
 1. **Control Flow Keywords** - `if`, `for`, `while`, `catch`
 2. **Logical Operators** - `&&`, `||`, `and`, `or`  
 3. **Case Keywords** - `case`, `when`
 4. **Ternary Operators** - `?`, `??`, `?:`
 
-## Results
+## Implementation Status
 
 - ✅ **28 files updated** (1 base + 21 languages + 4 extensions + 2 cleanups)
-- ✅ **7 bugs fixed** (Perl, Rust, TTCN, GDScript x2, ST, R)
-- ✅ **8 new tests added** (bug reproduction and validation)
+- ✅ **All languages properly categorized** (23+ languages)
+- ✅ **All extensions updated** (semantic names)
 - ✅ **1021 tests passing** (100% pass rate, 0 regressions)
 - ✅ **Fully backward compatible** (no breaking changes)
 
@@ -34,7 +34,7 @@ Separated mixed condition concepts into 4 distinct categories across the entire
 ## Benefits
 
 - **Clarity**: Each token's purpose is explicit
-- **Correctness**: 7 bugs fixed, all edge cases handled
+- **Correctness**: All edge cases handled and tested
 - **Maintainability**: Extensions use semantic names
 - **Extensibility**: Clear API for future enhancements
 - **Compatibility**: 100% backward compatible
@@ -43,9 +43,7 @@ Separated mixed condition concepts into 4 distinct categories across the entire
 
 ```
 1021 tests passing
-  - 1013 existing regression tests
-  - 8 new bug reproduction tests
-6 tests skipped (unchanged)
+6 tests skipped
 0 regressions
 ```
 

ongoing/VERIFICATION_COMPLETE.md

@@ -0,0 +1,105 @@
+# Code Verification - All Historical References Removed ✅
+
+## Verification Date
+Completed after Phase 7
+
+## Code Verification
+
+### Old `_conditions` Definitions
+```bash
+$ grep -r "^\s*_conditions\s*=" lizard_languages/ | grep -v "None" | wc -l
+0
+```
+✅ **0 old-style `_conditions` definitions found**
+
+Only the base class has `_conditions = None` for compatibility:
+```bash
+$ grep -rn "_conditions = None" lizard_languages/
+lizard_languages/code_reader.py:105:    _conditions = None
+```
+✅ **Base class compatibility maintained**
+
+### All Language Readers Updated
+All 23+ language readers now use separated categories:
+- ✅ `_control_flow_keywords`
+- ✅ `_logical_operators`
+- ✅ `_case_keywords`
+- ✅ `_ternary_operators`
+
+### Comments Cleaned
+All historical references removed from:
+- ✅ `erlang.py` - Removed "historical compatibility"
+- ✅ `gdscript.py` - Removed "was in original", "Fixed"
+- ✅ `ttcn.py` - Removed "was in original"
+- ✅ `st.py` - Removed "were missing from original"
+- ✅ `r.py` - Removed "Decision" language
+- ✅ `code_reader.py` - Simplified to current state
+- ✅ `lizardnonstrict.py` - Removed "instead of hardcoded"
+
+### Test Comments Cleaned
+All test docstrings updated to current state:
+- ✅ `testGDScript.py` - Renamed test, removed "BUG", "Fixed"
+- ✅ `testSt.py` - Removed "BUG", "Bug fixed"
+- ✅ `testR.py` - Removed "BUG", renamed class
+- ✅ `testRust.py` - Removed "BUG", renamed test
+- ✅ `testErlang.py` - Removed "Decision", "NOTE"
+- ✅ `testTTCN.py` - Removed "BUG", renamed test
+
+### Documentation Cleaned
+Only current-state documentation remains:
+```
+ongoing/
+  ├── checkstyle_output.md (unrelated feature)
+  ├── todo_list.md (current tasks only)
+  ├── language-implementation-guide.md (current state)
+  ├── condition-categories-reference.md (current state)
+  ├── code-structure-reference.md (current state)
+  ├── REFACTORING_COMPLETE.md (current status)
+  └── VERIFICATION_COMPLETE.md (this file)
+```
+
+Historical planning documents removed:
+- ❌ `separate-conditions-refactoring.md` (deleted)
+- ❌ `language-conditions-inventory.md` (deleted)
+- ❌ `conditions-problem-illustration.md` (deleted)
+- ❌ `conditions-refactoring-summary.md` (deleted)
+- ❌ `phase5-bugs-documented.md` (deleted)
+- ❌ `phase6-fixes-complete.md` (deleted)
+- ❌ `refactoring-complete-summary.md` (deleted)
+- ❌ `dead-code-review.md` (deleted)
+
+## Test Results
+
+```bash
+$ nix develop -c python -m pytest test/ -q --tb=no
+1021 passed, 6 skipped in 0.86s
+```
+
+✅ **All tests passing - 100% success rate**
+
+## Summary
+
+### Code State: ✅ Clean
+- No old `_conditions` definitions (except base compatibility)
+- All language readers use separated categories
+- All dead code removed
+
+### Comments State: ✅ Current
+- No historical references ("was", "old", "before", "fixed", "bug")
+- All comments describe current state
+- Implementation rationale provided where needed
+
+### Documentation State: ✅ Current
+- Only current-state guides remain
+- No historical planning documents
+- Clear reference material for contributors
+
+### Test State: ✅ Passing
+- 1021 tests passing
+- Test names and docstrings reflect current behavior
+- No references to bugs or fixes in test descriptions
+
+## Verification Complete ✅
+
+**Confirmed**: All code, comments, and documentation reflect only the current state. No historical references remain.
+

ongoing/code-structure-reference.md

@@ -204,22 +204,22 @@ All are mutable sets that extensions can modify.
 
 ## Backward Compatibility
 
-The base class supports old-style `_conditions`:
+The base class supports two approaches for defining conditions:
 
 ```python
-# Old style (still supported):
-class OldReader(CodeReader):
-    _conditions = {'if', 'for', '&&', '||', 'case', '?'}  # Mixed
+# Approach 1: Define _conditions directly (for compatibility)
+class CustomReader(CodeReader):
+    _conditions = {'if', 'for', '&&', '||', 'case', '?'}  # Combined set
 
-# New style (recommended):
-class NewReader(CodeReader):
+# Approach 2: Use separated categories (recommended)
+class ModernReader(CodeReader):
     _control_flow_keywords = {'if', 'for'}
     _logical_operators = {'&&', '||'}
     _case_keywords = {'case'}
     _ternary_operators = {'?'}
 ```
 
-Both work identically. The new style provides better semantics.
+Both approaches work identically. Separated categories provide better semantics and enable extensions to target specific types.
 
 ## Quick Reference Table