lizard 1.18.0__py2.py3-none-any.whl → 1.20.0__py2.py3-none-any.whl

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)
@@ -39,6 +42,22 @@ class CSharpStates(CLikeStates):
             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

lizard_languages/erlang.py

@@ -13,7 +13,15 @@ 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 expansion operator (e.g., ?MODULE, ?EMPTY_NODE)
+    # Unlike C-style ternary, it's for compile-time macro substitution
+    # Included in ternary_operators because macro usage adds to code complexity
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(ErlangReader, self).__init__(context)

lizard_languages/fortran.py

@@ -19,12 +19,11 @@ class FortranReader(CodeReader, FortranCommentsMixin):
     ext = ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
     language_names = ['fortran']
 
-    # Conditions need to have all the cases because the matching is case-insensitive
-    # and is not done here.
-    _conditions = {
-        'IF', 'DO', '.AND.', '.OR.', 'CASE',
-        'if', 'do', '.and.', '.or.', 'case'
-    }
+    # Separated condition categories (case-insensitive language)
+    _control_flow_keywords = {'IF', 'DO', 'if', 'do'}
+    _logical_operators = {'.AND.', '.OR.', '.and.', '.or.'}
+    _case_keywords = {'CASE', 'case'}
+    _ternary_operators = set()
     _blocks = [
         'PROGRAM', 'MODULE', 'SUBMODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE',
         'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE'

lizard_languages/gdscript.py

@@ -9,8 +9,12 @@ class GDScriptReader(PythonReader):
 
     ext = ['gd']
     language_names = ['GDScript']
-    _conditions = set(['if', 'else', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elif', 'for', 'while', 'catch', 'do'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(GDScriptReader, self).__init__(context)

lizard_languages/kotlin.py

@@ -13,9 +13,12 @@ class KotlinReader(CodeReader, CCppCommentsMixin, SwiftReplaceLabel):
 
     ext = ['kt', 'kts']
     language_names = ['kotlin']
-    _conditions = {
-        'if', 'for', 'while', 'catch', '&&', '||', '?:'
-    }
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = set()  # Kotlin uses 'when' expressions, not case
+    _ternary_operators = {'?:'}  # Elvis operator
 
     def __init__(self, context):
         super(KotlinReader, self).__init__(context)

lizard_languages/perl.py

@@ -19,8 +19,13 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['pl', 'pm']
     language_names = ['perl']
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach',
-                       '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elsif', 'unless', 'while', 'until', 'for', 
+                              'foreach', 'when', 'given', 'default', 'do'}
+    _logical_operators = {'&&', '||'}  # Perl also has 'and', 'or' with different precedence
+    _case_keywords = set()
+    _ternary_operators = {'?', ':'}  # Both parts of ternary operator
 
     def __init__(self, context):
         super(PerlReader, self).__init__(context)
@@ -65,8 +70,7 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
 
 class PerlStates(CodeStateMachine):
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach',
-                       '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
+    # Note: _conditions removed - now inherited from PerlReader
 
     def __init__(self, context):
         super(PerlStates, self).__init__(context)

lizard_languages/php.py

@@ -231,8 +231,12 @@ class PHPReader(CodeReader, CCppCommentsMixin):
 
     ext = ['php']
     language_names = ['php']
-    _conditions = set(['if', 'elseif', 'for', 'foreach', 'while', '&&', '||', '?',
-                       'catch', 'case', 'match'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elseif', 'for', 'foreach', 'while', 'catch', 'match'}
+    _logical_operators = {'&&', '||'}  # PHP also has 'and', 'or' with different precedence
+    _case_keywords = {'case'}
+    _ternary_operators = {'?'}
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):

lizard_languages/plsql.py

@@ -0,0 +1,422 @@
+"""
+Language parser for PL/SQL (Oracle's Procedural Language extension to SQL)
+
+This module implements complexity analysis for PL/SQL code, supporting:
+- Procedures, Functions, and Triggers
+- Package Bodies (not specifications - they only contain signatures)
+- Nested procedures and functions
+- Anonymous blocks with nested functions (blocks themselves aren't counted)
+- Control structures: IF/ELSIF/ELSE, CASE/WHEN, LOOP/WHILE/FOR
+- Exception handlers
+- Cursor declarations and cursor FOR loops
+
+Design Decisions:
+- EXIT WHEN: The WHEN keyword is filtered out by the preprocessor because
+  "EXIT WHEN condition" is not a branching construct - it's a conditional
+  exit that doesn't create alternate execution paths. The LOOP itself adds
+  complexity.
+
+- CONTINUE WHEN: Similar to EXIT WHEN, the WHEN is counted as it does create
+  a branch in the loop execution.
+
+- GOTO: Does not add to cyclomatic complexity as it's just an unconditional
+  jump, not a decision point.
+
+- Standalone LOOP: Adds +1 complexity as it creates a repeating path.
+
+- FOR/WHILE LOOP: The FOR/WHILE keyword adds complexity; the following LOOP
+  keyword is part of the same construct and doesn't add additional complexity.
+
+- Parameter Counting: Currently counts all non-whitespace tokens and commas
+  in parameter lists. This approach works but differs from some other language
+  implementations.
+"""
+
+from .code_reader import CodeReader, CodeStateMachine
+from .clike import CCppCommentsMixin
+
+
+class PLSQLReader(CodeReader, CCppCommentsMixin):
+    """
+    Reader for PL/SQL language supporting procedures, functions, packages,
+    and core control structures.
+    """
+
+    ext = ["sql", "pks", "pkb", "pls", "plb", "pck"]
+    language_names = ["plsql", "pl/sql"]
+
+    # Separated condition categories
+    # Note: 'loop' is NOT in this set because LOOP has special handling:
+    # - standalone LOOP adds +1
+    # - LOOP after WHILE/FOR should not add (it's part of the compound statement)
+    _control_flow_keywords = {"if", "elsif", "when", "while", "for"}
+    _logical_operators = {"and", "or"}
+    _case_keywords = set()  # PL/SQL uses 'when' in case expressions
+    _ternary_operators = set()
+
+    def __init__(self, context):
+        super(PLSQLReader, self).__init__(context)
+        self.parallel_states = [PLSQLStates(context)]
+        # PL/SQL is case-insensitive, so add both lowercase and uppercase versions
+        # of keywords to the conditions set for the automatic condition counter
+        self.conditions = self.conditions | {c.upper() for c in self.conditions}
+
+    def preprocess(self, tokens):
+        """
+        Preprocess tokens to handle PL/SQL-specific constructs.
+        Merge compound keywords to prevent the condition counter from double-counting:
+        - "END IF", "END LOOP", "END CASE", "END WHILE", "END FOR" -> single tokens
+        - "EXIT WHEN" -> remove the WHEN keyword (EXIT doesn't create a branch)
+        """
+        last_nonwhitespace_token = None
+        pending_tokens = []
+
+        for token in tokens:
+            if not token.isspace() or token == "\n":
+                token_upper = token.upper()
+
+                # Handle "END IF", "END LOOP", etc.
+                if (
+                    last_nonwhitespace_token
+                    and last_nonwhitespace_token.upper() == "END"
+                ):
+                    if token_upper in ("IF", "LOOP", "CASE", "WHILE", "FOR"):
+                        # Merge into "END_IF", "END_LOOP", etc.
+                        yield "END_" + token_upper
+                        last_nonwhitespace_token = None
+                        pending_tokens = []
+                        continue
+
+                # Handle "EXIT WHEN" - skip the WHEN keyword
+                if (
+                    last_nonwhitespace_token
+                    and last_nonwhitespace_token.upper() == "EXIT"
+                    and token_upper == "WHEN"
+                ):
+                    # Skip this WHEN keyword
+                    pending_tokens = []
+                    continue
+
+                # Yield any pending tokens
+                if last_nonwhitespace_token:
+                    yield last_nonwhitespace_token
+                for pending in pending_tokens:
+                    yield pending
+                pending_tokens = []
+
+                # Update tracking
+                last_nonwhitespace_token = token
+            else:
+                # Accumulate whitespace
+                pending_tokens.append(token)
+
+        # Don't forget the last tokens
+        if last_nonwhitespace_token:
+            yield last_nonwhitespace_token
+        for pending in pending_tokens:
+            yield pending
+
+    @staticmethod
+    def generate_tokens(source_code, addition="", token_class=None):
+        """
+        Generate tokens for PL/SQL code.
+        PL/SQL uses:
+        - Single-line comments: --
+        - Multi-line comments: /* */
+        - String literals: 'text' (with '' for escaping)
+        - Assignment operator: :=
+        """
+        # Add PL/SQL-specific patterns
+        addition = r"|--[^\n]*" + addition  # Single-line comment starting with --
+        return CodeReader.generate_tokens(source_code, addition, token_class)
+
+    def get_comment_from_token(self, token):
+        """
+        Override to recognize PL/SQL's -- line comments in addition to /* */ block comments.
+        PL/SQL uses -- for single-line comments (like SQL standard).
+
+        Note: This method correctly identifies -- comments, but due to a limitation in
+        the NLOC calculation, these comments may still be counted in NLOC.
+        """
+        if token.startswith("--"):
+            return token  # Return full comment token (like Lua does)
+        # Delegate to parent for /* */ and // comments
+        return super().get_comment_from_token(token)
+
+
+class PLSQLStates(CodeStateMachine):
+    """
+    State machine for parsing PL/SQL code structure.
+    """
+
+    def __init__(self, context):
+        super(PLSQLStates, self).__init__(context)
+        self.in_parameter_list = False
+        self.last_control_keyword = None  # Track FOR/WHILE to avoid counting their LOOP
+        self.declaring_nested_function = (
+            False  # Track if we're declaring a nested function
+        )
+
+    def _state_global(self, token):
+        """Global state - looking for function/procedure/trigger declarations."""
+        token_lower = token.lower()
+
+        if token_lower == "procedure":
+            self.next(self._procedure_name)
+        elif token_lower == "function":
+            self.next(self._function_name)
+        elif token_lower == "trigger":
+            self.next(self._trigger_name)
+
+    def _procedure_name(self, token):
+        """Read procedure name."""
+        if token.isspace() or token == "\n":
+            return
+        if token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        else:
+            # Check if this is a nested function
+            if self.declaring_nested_function:
+                self.context.push_new_function(token)
+                self.declaring_nested_function = False
+            else:
+                self.context.try_new_function(token)
+            self.next(self._procedure_after_name)
+
+    def _procedure_after_name(self, token):
+        """After procedure name, look for parameters or IS/AS."""
+        if token == ".":
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual procedure name
+            self.next(self._procedure_name_after_dot)
+        elif token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _procedure_name_after_dot(self, token):
+        """Read the actual procedure name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual procedure name
+        self.context.current_function.name = token
+        self.next(self._procedure_after_name)
+
+    def _function_name(self, token):
+        """Read function name."""
+        if token.isspace() or token == "\n":
+            return
+        if token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        else:
+            # Check if this is a nested function
+            if self.declaring_nested_function:
+                self.context.push_new_function(token)
+                self.declaring_nested_function = False
+            else:
+                self.context.try_new_function(token)
+            self.next(self._function_after_name)
+
+    def _function_after_name(self, token):
+        """After function name, look for parameters, RETURN, or IS/AS."""
+        if token == ".":
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual function name
+            self.next(self._function_name_after_dot)
+        elif token == "(":
+            self.in_parameter_list = True
+            self.next(self._parameters, "(")
+        elif token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _function_name_after_dot(self, token):
+        """Read the actual function name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual function name
+        self.context.current_function.name = token
+        self.next(self._function_after_name)
+
+    def _return_type(self, token):
+        """Skip return type declaration."""
+        if token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip everything else (return type tokens)
+
+    def _parameters(self, token):
+        """Read parameters."""
+        if token == ")":
+            self.in_parameter_list = False
+            self.next(self._after_parameters)
+        elif token == ",":
+            # Each comma separates parameters
+            self.context.parameter(token)
+        elif not token.isspace() and token != "\n":
+            # Track non-whitespace tokens as potential parameters
+            self.context.parameter(token)
+
+    def _after_parameters(self, token):
+        """After parameters, look for IS/AS or RETURN."""
+        if token.lower() == "return":
+            self.next(self._return_type)
+        elif token.lower() in ("is", "as"):
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        # Skip whitespace and other tokens
+
+    def _trigger_name(self, token):
+        """Read trigger name."""
+        if token.isspace() or token == "\n":
+            return
+        # Trigger name found
+        self.context.try_new_function(token)
+        self.seen_trigger_name_token = False  # Track if we've seen non-whitespace after name
+        self.next(self._trigger_after_name)
+
+    def _trigger_after_name(self, token):
+        """After trigger name, skip until DECLARE or BEGIN."""
+        token_lower = token.lower()
+
+        # Only check for dot immediately after trigger name (before any other tokens)
+        if token == "." and not self.seen_trigger_name_token:
+            # Schema-qualified name: the previous token was the schema,
+            # next non-whitespace token will be the actual trigger name
+            self.next(self._trigger_name_after_dot)
+            return
+
+        # Mark that we've seen a non-whitespace token after the trigger name
+        if not token.isspace() and token != "\n":
+            self.seen_trigger_name_token = True
+
+        if token_lower == "declare":
+            self.context.confirm_new_function()
+            self.next(self._state_before_begin)
+        elif token_lower == "begin":
+            self.context.confirm_new_function()
+            self.br_count = 1
+            self.next(self._state_body)
+        # Skip everything else (BEFORE/AFTER, INSERT/UPDATE/DELETE, ON table_name, FOR EACH ROW, etc.)
+
+    def _trigger_name_after_dot(self, token):
+        """Read the actual trigger name after schema.dot."""
+        if token.isspace() or token == "\n":
+            return
+        # Replace the previous (schema) name with the actual trigger name
+        self.context.current_function.name = token
+        self.seen_trigger_name_token = False  # Reset for the real trigger name
+        self.next(self._trigger_after_name)
+
+    def _state_before_begin(self, token):
+        """
+        State between IS/AS and BEGIN - this is the declaration section.
+        Watch for nested procedures/functions and the BEGIN keyword.
+        """
+        token_lower = token.lower()
+
+        # Check for nested procedure/function declarations
+        if token_lower == "procedure":
+            self.declaring_nested_function = True
+            # Store current br_count level to know when nested function ends
+            if not hasattr(self, "nested_br_level"):
+                self.nested_br_level = 0
+            self.next(self._procedure_name)
+            return
+        elif token_lower == "function":
+            self.declaring_nested_function = True
+            # Store current br_count level to know when nested function ends
+            if not hasattr(self, "nested_br_level"):
+                self.nested_br_level = 0
+            self.next(self._function_name)
+            return
+        elif token_lower == "begin":
+            # Start of the implementation body
+            # Check if we had nested functions and need to reset br_count tracking
+            if hasattr(self, "nested_br_level"):
+                self.br_count = self.nested_br_level + 1
+                delattr(self, "nested_br_level")
+            else:
+                self.br_count = 1  # Initialize counter for the first BEGIN
+            self.next(self._state_body)
+
+    def _state_body(self, token):
+        """
+        Process function/procedure body.
+        Track control structures for cyclomatic complexity.
+        Manually track BEGIN/END blocks.
+        """
+        token_lower = token.lower()
+        token_upper = token.upper()
+
+        # Check for merged compound keywords like "END_IF", "END_LOOP", etc.
+        # These are created by the preprocessor
+        if token_lower.startswith("end_"):
+            # This is a compound END keyword, reset tracking
+            self.last_control_keyword = None
+            return
+
+        # Handle nested procedure/function declarations
+        if token_lower == "procedure":
+            self.next(self._procedure_name)
+            return
+        elif token_lower == "function":
+            self.next(self._function_name)
+            return
+
+        # Track FOR and WHILE to know when LOOP follows them
+        if token_upper in ("FOR", "WHILE"):
+            self.last_control_keyword = token_upper
+
+        # Handle LOOP keyword manually
+        # - Standalone LOOP adds +1 complexity
+        # - LOOP after FOR/WHILE does not add complexity (already counted for FOR/WHILE)
+        elif token_upper == "LOOP":
+            if self.last_control_keyword not in ("FOR", "WHILE"):
+                # This is a standalone LOOP, add complexity
+                self.context.add_condition()
+            # Reset tracking after processing LOOP
+            self.last_control_keyword = None
+
+        # PL/SQL uses BEGIN/END instead of {}
+        if token_lower == "begin":
+            self.br_count += 1
+            self.context.add_bare_nesting()
+        elif token_lower == "end":
+            # This is a standalone END (for BEGIN/END block)
+            self.br_count -= 1
+            if self.br_count == 0:
+                # This END closes the function/procedure
+                # Check if we have a parent function BEFORE ending (stack gets popped)
+                has_parent = len(self.context.stacked_functions) > 0
+                self.context.end_of_function()
+                # Return to appropriate state based on whether this was nested
+                if has_parent:
+                    # Return to parent function's declaration section
+                    self.next(self._state_before_begin)
+                else:
+                    # No parent function, return to global
+                    self.next(self._state_global)
+                return
+            else:
+                self.context.pop_nesting()
+
+        # Note: Basic conditions (if, elsif, when, while, for, and, or)
+        # are automatically counted by the condition_counter processor
+        # based on the _conditions set in the Reader class.

lizard_languages/python.py

@@ -29,10 +29,12 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['py']
     language_names = ['python']
-    _conditions = set([
-        'if', 'for', 'while', 'and', 'or',
-        'elif', 'except', 'finally'
-    ])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elif', 'for', 'while', 'except', 'finally'}
+    _logical_operators = {'and', 'or'}
+    _case_keywords = set()  # Python uses if/elif, not case
+    _ternary_operators = set()  # Python uses 'x if c else y' syntax, not ?
 
     def __init__(self, context):
         super(PythonReader, self).__init__(context)

lizard_languages/r.py

@@ -12,12 +12,15 @@ class RReader(CodeReader, ScriptLanguageMixIn):
     ext = ['r', 'R']
     language_names = ['r', 'R']
 
-    # R-specific conditions that increase cyclomatic complexity
-    _conditions = {
-        'if', 'else if', 'for', 'while', 'repeat', 'switch',
-        '&&', '||', '&', '|', 'ifelse',
-        'tryCatch', 'try'
-    }
+    # Separated condition categories
+    _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
+    # 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()
 
     def __init__(self, context):
         super(RReader, self).__init__(context)

lizard_languages/rubylike.py

@@ -97,9 +97,12 @@ class RubylikeStateMachine(CodeStateMachine):
 class RubylikeReader(CodeReader, ScriptLanguageMixIn):
     # pylint: disable=R0903
 
-    _conditions = set(['if', 'until', 'for', 'while', 'and', 'or',
-                       'elsif', 'elseif', 'rescue',
-                       'ensure', 'when', '||', '&&', '?'])
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'elsif', 'elseif', 'until', 'for', 'while', 
+                              'rescue', 'ensure', 'when'}
+    _logical_operators = {'and', 'or', '||', '&&'}  # Both word and symbol forms
+    _case_keywords = set()  # Ruby uses 'when' for case expressions
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(RubylikeReader, self).__init__(context)

lizard_languages/rust.py

@@ -12,8 +12,13 @@ class RustReader(CodeReader, CCppCommentsMixin):
 
     ext = ['rs']
     language_names = ['rust']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'match', 'where'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch', 'match', 'where'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = set()  # Rust uses match arms, not case keyword
+    # Note: '?' in Rust is the error propagation operator, not ternary
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super().__init__(context)

lizard_languages/scala.py

@@ -12,8 +12,12 @@ class ScalaReader(CodeReader, CCppCommentsMixin):
 
     ext = ['scala']
     language_names = ['scala']
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', 'do'])
+    
+    # Separated condition categories
+    _control_flow_keywords = {'if', 'for', 'while', 'catch', 'do'}
+    _logical_operators = {'&&', '||'}
+    _case_keywords = {'case'}  # Pattern matching
+    _ternary_operators = {'?'}
 
     def __init__(self, context):
         super(ScalaReader, self).__init__(context)