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

{lizard-1.17.31.dist-info → lizard-1.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.31
+Version: 1.18.0
 Summary: A code analyzer without caring the C/C++ header files. It works with Java, C/C++, JavaScript, Python, Ruby, Swift, Objective C. Metrics includes cyclomatic complexity number etc.
 Home-page: http://www.lizard.ws
 Download-URL: https://pypi.python.org/lizard/
@@ -73,6 +73,8 @@ A list of supported languages:
 -  Erlang
 -  Zig
 -  Perl
+-  Structured Text (St)
+-  R
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use
@@ -413,3 +415,5 @@ Lizard is also used as a plugin for fastlane to help check code complexity and s
 - `European research project FASTEN (Fine-grained Analysis of SofTware Ecosystems as Networks, <http://fasten-project.eu/)>`_
   - `for a quality analyzer <https://github.com/fasten-project/quality-analyzer>`_
 
+
+

{lizard-1.17.31.dist-info → lizard-1.18.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lizard.py,sha256=H0EgGsU0ou4IlRY9AxIyY_O4_WO8trZda4GGM7a4kNQ,41403
+lizard.py,sha256=B0g5lEp5me31bQpjfMKVayF0iUfH0PalVecOKeUX3-A,41365
 lizard_ext/__init__.py,sha256=AkZYVqCgd7XX1hMwLMyh_ABm9geIHmobEch-thYXZz8,932
 lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
-lizard_ext/checkstyleoutput.py,sha256=puuTq5IfM48NkDdds2FjF1BFq1QDGfsf5GahLTVfN6Y,1213
+lizard_ext/checkstyleoutput.py,sha256=UzDHg837ErEZepXkR8I8YCoz2r1lkmzGctMA7dpyB-M,1245
 lizard_ext/csvoutput.py,sha256=43fhmo8kB85qcdujCwySGNuTC4FkKUPLqIApPeljPnA,2663
 lizard_ext/default_ordered_dict.py,sha256=YbVz6nPlQ6DjWc_EOFBz6AJN2XLo9dpnUdeyejQvUDE,831
 lizard_ext/extension_base.py,sha256=rnjUL2mqSGToUVYydju7fa8ZwynLPY8S1F17gIJP55I,346
@@ -26,10 +26,10 @@ lizard_ext/lizardns.py,sha256=8pztUoRS_UWN24MawwxeHEJgYh49id5PWODUBb6O72U,4184
 lizard_ext/lizardoutside.py,sha256=FGm2tbBZ17-2OCgmQlD-vobUCfQKb0FAygf86eM3xuM,336
 lizard_ext/lizardstatementcount.py,sha256=xYk6ixSIItSE1BWQXzrWmduFgGhA3VR817SNKLffyVQ,1182
 lizard_ext/lizardwordcount.py,sha256=2QYXD7-AtkkgAbi9VSidunMbSsGQ7MKYb6IT-bS-cok,7575
-lizard_ext/version.py,sha256=N4oSGH5svpjDluQQOHRznK3TrM-OyaJq6FN_Yuc5pvw,182
+lizard_ext/version.py,sha256=WiI5ub_2twuTf6tscOzwP6MNdZV6kq-ElL2-2HqdUXc,181
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=ArNmUrVSU6HFxhDka1-vWMZpVIM39P-gqv6BoOLNMV8,1522
-lizard_languages/clike.py,sha256=INd5tkvwEVZm7dx2yHG2OIFHZn7JzQGmnT9WQNFZ2XU,11110
+lizard_languages/__init__.py,sha256=NsYspQ6h--XHMJrIcmOxlZRF4f_l5M7JprenLBz2oIE,1559
+lizard_languages/clike.py,sha256=RICnhzBzLbMwpceo3X-z7_-hcTZmGAZKGqpKgJf0G0o,13598
 lizard_languages/code_reader.py,sha256=IfEHg9lzKnyCipX9xscgyGEOovll5qr9dCe5cSX2sJM,6852
 lizard_languages/csharp.py,sha256=EfFAIOIcJXUUhXTlZApXGSlzG34NZvHM9OSe6m7hpv0,2141
 lizard_languages/erlang.py,sha256=7YJS2cMyXDKEV_kpH8DzBARxFCFcjKuTOPSQ3K52auU,3860
@@ -39,31 +39,31 @@ lizard_languages/go.py,sha256=sntz0jOEuj4klPipoTFd16UDK1fAUQfwK7YX_cLMZAc,1346
 lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
 lizard_languages/java.py,sha256=HQBTZjUKbUJwgmtLYIzJrWtPpFP3ZdBP_NJK7YOXZC0,6424
 lizard_languages/javascript.py,sha256=vniCNMW-ea9Jpv6c8qCcjLVDYjT8VztjXigp5XRWt0E,317
-lizard_languages/js_style_language_states.py,sha256=6mLrHfvDC4oHttKsSRGkE-ayG8uKSEm4E4rlhaUN5lA,6396
 lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
-lizard_languages/jsx.py,sha256=TLH93qrZO2r_tiiv1XBIbw2_mbUMjwCZAuBz5vG5oBw,11696
 lizard_languages/kotlin.py,sha256=v_o2orEzA5gB9vM_0h-E4QXjrc5Yum-0K6W6_laOThc,2844
 lizard_languages/lua.py,sha256=3nqBcunBzJrhv4Iqaf8xvbyqxZy3aSxJ-IiHimHFlac,1573
 lizard_languages/objc.py,sha256=2a1teLdaXZBtCeFiIZer1j_sVx9LZ1CbF2XfnqlvLmk,2319
 lizard_languages/perl.py,sha256=136w620eECe_t-kmlRUGrsZSxQNo2JQ_PZTSQfCSmHY,11987
 lizard_languages/php.py,sha256=UV40p8WzNC64NQ5qElPKzcFTjVt5kenLMz-eKYlcnMY,9940
-lizard_languages/python.py,sha256=4AK0JAPBSM7eKrqDdSaHfewCGAYMzdhUhi5kZK4u23k,3847
+lizard_languages/python.py,sha256=AsL0SmQ73zhNS1iGi4Z8VtuUE0VjqBzo9W8W0mjqL0E,5790
+lizard_languages/r.py,sha256=IoyMhmFtUmTji6rm6-fqss_j_kvIHu3JjABRh6RNys0,12583
 lizard_languages/ruby.py,sha256=HL1ZckeuUUJU3QSVAOPsG_Zsl0C6X2PX5_VaWqclzkM,2277
 lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
-lizard_languages/rust.py,sha256=vfBBktNwIZL8AiaAJ5EW8o4rL7_TwjDo3QhpfxxecfE,596
+lizard_languages/rust.py,sha256=WarDHnFZv99Yu3_C5DpZfLS8dVWz6AcOzo2dzLW94rA,817
 lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
 lizard_languages/script_language.py,sha256=SKe45AbO6Z-axbN8KW_g7jf9g7YTXZ6dWzJj4ubDsM8,1172
 lizard_languages/solidity.py,sha256=Z0GD7U5bI5eUikdy7m_iKWeFD5yXRYq4r3zycscOhJQ,553
+lizard_languages/st.py,sha256=7fpOfNAoUjNY8RCHSYLufnOzZTUkKwjVvcyRyM1xP2Y,4160
 lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,2450
 lizard_languages/tnsdl.py,sha256=pGcalA_lHY362v2wwPS86seYBOOBBjvmU6vd4Yy3A9g,2803
-lizard_languages/tsx.py,sha256=AgpULWV9VEF4wJGtNZeeOl6NuTiQOstM8P3jObz-_xY,1249
+lizard_languages/tsx.py,sha256=1oOVCcz5yHkmYLYGhSarCMSXfGVasweklAqqapkuNR4,17160
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=fiEiGs0VO8uofsLcOD7t8UzKp0Un9SSbfQTU87mhNVo,5626
+lizard_languages/typescript.py,sha256=C8VWmHLGGYwCrP6hJ9HmJ-PETrKux4npjOzDN6AkTGU,12347
 lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
 lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
-lizard-1.17.31.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.31.dist-info/METADATA,sha256=8P82zQ9bK0enmWJ9bOSezN6Ly1oO5WvgfWO6i0jSEx4,16230
-lizard-1.17.31.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.17.31.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
-lizard-1.17.31.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.31.dist-info/RECORD,,
+lizard-1.18.0.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.18.0.dist-info/METADATA,sha256=BX2GeLwA0iQpWmDi0wYg4xXCTISh6Un8alaLcJhuRxc,16260
+lizard-1.18.0.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.18.0.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
+lizard-1.18.0.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.18.0.dist-info/RECORD,,

{lizard-1.17.31.dist-info → lizard-1.18.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 lizard = lizard:main
+

lizard.py

@@ -623,7 +623,7 @@ def whitelist_filter(warnings, script=None, whitelist=None):
 
     def get_whitelist(whitelist):
         if os.path.isfile(whitelist):
-            return open(whitelist, mode='r').read()
+            return auto_read(whitelist)
         if whitelist != DEFAULT_WHITELIST:
             print("WARNING: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
             print("WARNING: the whitelist \""+whitelist+"\" doesn't exist.")
@@ -923,12 +923,12 @@ def get_all_source_files(paths, exclude_patterns, lans):
             for path in paths:
                 gitignore_path = os.path.join(path, '.gitignore')
                 if os.path.exists(gitignore_path):
-                    with open(gitignore_path, 'r') as gitignore_file:
-                        # Read lines and strip whitespace and empty lines
-                        patterns = [line.strip() for line in gitignore_file.readlines()]
-                        patterns = [p for p in patterns if p and not p.startswith('#')]
-                        gitignore_spec = pathspec.PathSpec.from_lines('gitwildmatch', patterns)
-                        base_path = path
+                    gitignore_file = auto_read(gitignore_path)
+                    # Read lines and strip whitespace and empty lines
+                    patterns = [line.strip() for line in gitignore_file.splitlines()]
+                    patterns = [p for p in patterns if p and not p.startswith('#')]
+                    gitignore_spec = pathspec.PathSpec.from_lines('gitwildmatch', patterns)
+                    base_path = path
                     break
         except ImportError:
             pass

lizard_ext/checkstyleoutput.py

@@ -2,6 +2,7 @@
 Checkstyle XML output for Lizard
 '''
 
+
 def checkstyle_output(all_result, verbose):
     result = all_result.result
     import xml.etree.ElementTree as ET
@@ -20,7 +21,8 @@ def checkstyle_output(all_result, verbose):
                     line=str(func.start_line),
                     column="0",
                     severity="info",
-                    message=f"{func.name} has {func.nloc} NLOC, {func.cyclomatic_complexity} CCN, {func.token_count} token, {len(func.parameters)} PARAM, {func.length} length",
+                    message=f"{func.name} has {func.nloc} NLOC, {func.cyclomatic_complexity} CCN, "
+                           f"{func.token_count} token, {len(func.parameters)} PARAM, {func.length} length",
                     source="lizard"
                 )
 
@@ -28,4 +30,4 @@ def checkstyle_output(all_result, verbose):
     import xml.dom.minidom
     rough_string = ET.tostring(checkstyle, 'utf-8')
     reparsed = xml.dom.minidom.parseString(rough_string)
-    return reparsed.toprettyxml(indent="  ") 
+    return reparsed.toprettyxml(indent="  ")

lizard_ext/version.py

@@ -3,4 +3,4 @@
 #
 # pylint: disable=missing-docstring,invalid-name
 
-version = "1.17.31"
+version = "1.18.0"

lizard_languages/__init__.py

@@ -21,10 +21,11 @@ from .rust import RustReader
 from .typescript import TypeScriptReader
 from .fortran import FortranReader
 from .solidity import SolidityReader
-from .jsx import JSXReader
 from .tsx import TSXReader
 from .vue import VueReader
 from .perl import PerlReader
+from .st import StReader
+from .r import RReader
 
 
 def languages():
@@ -50,10 +51,11 @@ def languages():
         SolidityReader,
         ErlangReader,
         ZigReader,
-        JSXReader,
         TSXReader,
         VueReader,
         PerlReader,
+        StReader,
+        RReader,
     ]
 
 

lizard_languages/clike.py

@@ -19,7 +19,7 @@ class CCppCommentsMixin(object):  # pylint: disable=R0903
 class CLikeReader(CodeReader, CCppCommentsMixin):
     ''' This is the reader for C, C++ and Java. '''
 
-    ext = ["c", "cpp", "cc", "mm", "cxx", "h", "hpp"]
+    ext = ["c", "cpp", "cc", "cxx", "h", "hpp"]
     language_names = ['cpp', 'c']
     macro_pattern = re.compile(r"#\s*(\w+)\s*(.*)", re.M | re.S)
 
@@ -162,6 +162,11 @@ class CLikeStates(CodeStateMachine):
     def _state_global(self, token):
         if token[0].isalpha() or token[0] in '_~':
             self.try_new_function(token)
+        elif token == '[':
+            # Check if this might be a lambda expression (C++ only)
+            # Java doesn't have lambda expressions, so skip lambda detection for Java
+            if not hasattr(self, 'class_name'):  # JavaStates has class_name attribute
+                self._state = self._state_lambda_check
 
     def _state_function(self, token):
         if token == '(':
@@ -310,3 +315,57 @@ class CLikeStates(CodeStateMachine):
     def _state_attribute(self, _):
         "Ignores function attributes with C++11 syntax, i.e., [[ attribute ]]."
         pass
+
+    def _state_lambda_check(self, token):
+        """Check if this is a lambda expression or a function attribute."""
+        if token == ']':
+            # This is a lambda expression [](params) or [capture](params)
+            # Skip the lambda and continue parsing normally
+            self._state = self._state_lambda_params
+        elif token == '[':
+            # This is a function attribute [[attribute]]
+            self._state = self._state_attribute
+        else:
+            # This is a lambda with capture list [capture](params)
+            # Skip until we find the closing bracket
+            self._state = self._state_lambda_capture
+
+    def _state_lambda_params(self, token):
+        """Handle lambda parameters and body."""
+        if token == '(':
+            # Start of parameter list, skip until closing parenthesis
+            self._state = self._state_lambda_param_list
+        else:
+            # No parameters, check for body
+            self._state = self._state_lambda_body
+
+    def _state_lambda_param_list(self, token):
+        """Handle lambda parameter list."""
+        if token == ')':
+            # End of parameter list, check for body
+            self._state = self._state_lambda_body
+        # Otherwise, continue in parameter list
+
+    def _state_lambda_body(self, token):
+        """Handle lambda body."""
+        if token == '{':
+            # Start of lambda body, skip until closing brace
+            self._state = self._state_lambda_body_skip
+        elif token == ';':
+            # Lambda without body, just a semicolon
+            self._state = self._state_global
+        # Otherwise, continue
+
+    def _state_lambda_body_skip(self, token):
+        """Skip lambda body until closing brace."""
+        if token == '}':
+            # End of lambda body, continue parsing normally
+            self._state = self._state_global
+        # Otherwise, continue skipping
+
+    def _state_lambda_capture(self, token):
+        """Handle lambda capture list."""
+        if token == ']':
+            # End of capture list, continue parsing normally
+            self._state = self._state_global
+        # Otherwise, continue in capture list

lizard_languages/python.py

@@ -37,6 +37,7 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
     def __init__(self, context):
         super(PythonReader, self).__init__(context)
         self.parallel_states = [PythonStates(context, self)]
+        self._last_meaningful_token = None  # Track the last meaningful token
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
@@ -46,6 +47,41 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
             r"|(?:\'\'\'(?:\\.|[^\']|\'(?!\'\')|\'\'(?!\'))*\'\'\')",
             token_class)
 
+    def process_token(self, token):
+        """Process triple-quoted strings used as comments.
+
+        Triple-quoted strings that are not docstrings (i.e., not immediately
+        after function definitions) should be treated like comments and not
+        counted in NLOC, but only if they appear to be standalone statements
+        rather than part of assignments or other expressions.
+
+        Returns:
+            bool: True if the token was handled specially, False otherwise
+        """
+        if (token.startswith('"""') or token.startswith("'''")) and len(token) >= 6:
+            # Check if this is likely a standalone comment (not a docstring)
+            # Docstrings are handled separately in _state_first_line
+            current_state = self.parallel_states[0]._state
+
+            # If we're not in the first line state, check if this is a standalone string
+            if current_state != current_state.__self__._state_first_line:
+                # Check if the immediate previous meaningful token suggests this is part of an expression
+                assignment_tokens = ['=', '+=', '-=', '*=', '/=', '%=', '//=', '**=', '&=', '|=', '^=',
+                                     '<<=', '>>=', '(', 'return', ',', '[', '+', '-', '*', '/', '%']
+
+                is_part_of_expression = self._last_meaningful_token in assignment_tokens
+
+                # Only treat as comment if it's NOT part of an expression
+                if not is_part_of_expression:
+                    # Subtract the NLOC contribution of this triple-quoted string
+                    self.context.add_nloc(-(token.count('\n') + 1))
+
+        # Update last meaningful token (ignore whitespace and newlines)
+        if token not in ['\n', ' ', '\t'] and not token.isspace():
+            self._last_meaningful_token = token
+
+        return False  # Continue with normal processing
+
     def preprocess(self, tokens):
         indents = PythonIndents(self.context)
         current_leading_spaces = 0

lizard_languages/r.py

@@ -0,0 +1,290 @@
+'''
+Language parser for R
+'''
+
+from .code_reader import CodeReader, CodeStateMachine
+from .script_language import ScriptLanguageMixIn
+
+
+class RReader(CodeReader, ScriptLanguageMixIn):
+    """R language reader for parsing R code and calculating complexity metrics."""
+
+    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'
+    }
+
+    def __init__(self, context):
+        super(RReader, self).__init__(context)
+        self.parallel_states = [RStates(context)]
+
+    def preprocess(self, tokens):
+        """Preprocess tokens - for now just pass them through."""
+        for token in tokens:
+            yield token
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        """Generate tokens for R code with R-specific patterns."""
+        # R-specific token patterns
+        r_patterns = (
+            r"|<-"          # Assignment operator <-
+            r"|->"          # Assignment operator ->
+            r"|%[a-zA-Z_*/>]+%"  # Special operators like %in%, %*%, %>%, %/%, etc.
+            r"|\.\.\."      # Ellipsis for variable arguments
+            r"|:::"         # Internal namespace operator (must come before ::)
+            r"|::"          # Namespace operator
+        )
+
+        return ScriptLanguageMixIn.generate_common_tokens(
+            source_code,
+            r_patterns + addition,
+            token_class
+        )
+
+
+class RStates(CodeStateMachine):
+    """State machine for parsing R function definitions and complexity."""
+
+    def __init__(self, context):
+        super(RStates, self).__init__(context)
+        self.recent_tokens = []  # Track recent tokens to find function names
+        self.brace_count = 0  # Track brace nesting for function bodies
+        self.in_braced_function = False  # Track if current function uses braces
+        self.additional_function_names = []  # Store additional names for multiple assignment
+
+    def _state_global(self, token):
+        """Global state - looking for function definitions."""
+        # Track recent non-whitespace tokens
+        if not token.isspace() and token != '\n':
+            self.recent_tokens.append(token)
+            if len(self.recent_tokens) > 10:  # Keep only last 10 tokens
+                self.recent_tokens.pop(0)
+
+        # Look for function keyword after assignment operators
+        if token == 'function':
+            # Check if we have recent tokens: [name, assignment_op, 'function']
+            if len(self.recent_tokens) >= 2:
+                # recent_tokens now contains [..., assignment_op, 'function']
+                assignment_op = self.recent_tokens[-2]  # The token before 'function'
+                if assignment_op in ['<-', '=']:
+                    # Handle multiple assignments by creating separate functions
+                    func_names = self._extract_function_names()
+
+                    # Create the first function (this will be the main one with the function body)
+                    self._start_function(func_names[0])
+                    self._state = self._function_params
+
+                    # Store additional names for later processing
+                    self.additional_function_names = func_names[1:] if len(func_names) > 1 else []
+                    return
+
+            # If we get here, it's an anonymous function or not a proper assignment
+            self._start_function("(anonymous)")
+            self._state = self._function_params
+
+    def _extract_function_names(self):
+        """Extract all function names from recent tokens, handling multiple assignments."""
+        if len(self.recent_tokens) < 3:
+            return ["(anonymous)"]
+
+        # Look backwards from the assignment operator to find all function names
+        # For multiple assignment like: a <- b <- c <- function(...)
+        # recent_tokens ends with [..., 'a', '<-', 'b', '<-', 'c', '<-', 'function']
+        assignment_index = len(self.recent_tokens) - 2  # Position of assignment operator
+
+        function_names = []
+        i = assignment_index - 1  # Start from token before assignment operator
+        current_name_tokens = []
+
+        while i >= 0:
+            token = self.recent_tokens[i]
+
+            # If we hit an assignment operator, we've found a complete variable name
+            if token in ['<-', '=']:
+                if current_name_tokens:
+                    function_names.append(''.join(reversed(current_name_tokens)))
+                    current_name_tokens = []
+                i -= 1
+                continue
+
+            # Stop if we hit keywords or operators that shouldn't be part of function names
+            if token in ['function', '(', ')', '{', '}', '\n']:
+                break
+
+            # Valid R identifier characters and dots
+            if token.replace('_', 'a').replace('.', 'a').isalnum() or token == '.':
+                current_name_tokens.append(token)
+                i -= 1
+            else:
+                break
+
+        # Add the last name if we have one
+        if current_name_tokens:
+            function_names.append(''.join(reversed(current_name_tokens)))
+
+        # Return names in the correct order (left to right as they appear in code)
+        return list(reversed(function_names)) if function_names else ["(anonymous)"]
+
+    def _extract_function_name(self):
+        """Extract the first function name (for backward compatibility)."""
+        names = self._extract_function_names()
+        return names[0] if names else "(anonymous)"
+
+    def _start_function(self, name):
+        """Start tracking a new function."""
+        self.context.restart_new_function(name)
+
+    def _function_params(self, token):
+        """Expecting function parameters."""
+        if token == '(':
+            self.context.add_to_long_function_name("(")
+            self._state = self._read_params
+        else:
+            # Single expression function without parentheses - rare in R
+            self._state = self._function_body
+            self._function_body(token)
+
+    def _read_params(self, token):
+        """Read function parameters until closing parenthesis."""
+        if token == ')':
+            self.context.add_to_long_function_name(")")
+            self._state = self._function_body
+        elif token not in ['\n'] and not token.isspace():
+            self.context.parameter(token)
+            if token != '(':
+                self.context.add_to_long_function_name(" " + token)
+
+    def _function_body(self, token):
+        """In function body - track complexity and nested functions."""
+        # Note: Complexity conditions are automatically counted by the framework
+        # based on reader.conditions, so we don't need to manually count them here
+
+        # Continue tracking tokens even in function body for nested function detection
+        if not token.isspace() and token != '\n':
+            self.recent_tokens.append(token)
+            if len(self.recent_tokens) > 10:  # Keep only last 10 tokens
+                self.recent_tokens.pop(0)
+
+        # Track braces
+        if token == '{':
+            if self.brace_count == 0:
+                self.in_braced_function = True
+            self.brace_count += 1
+        elif token == '}':
+            self.brace_count -= 1
+            if self.brace_count == 0 and self.in_braced_function:
+                # End of braced function
+                self._end_current_function()
+                return
+
+        # Handle nested functions - treat them as separate functions
+        if token == 'function':
+            # Check if this is a nested function assignment
+            if len(self.recent_tokens) >= 2:
+                assignment_op = self.recent_tokens[-2]  # The token before 'function'
+                if assignment_op in ['<-', '=']:
+                    # End current function first
+                    self.context.end_of_function()
+
+                    # Handle multiple assignments for nested functions too
+                    func_names = self._extract_function_names()
+
+                    # Start a new function for the nested function
+                    self._start_function(func_names[0])
+                    self._state = self._function_params
+                    # Reset brace counting for the new function
+                    self.brace_count = 0
+                    self.in_braced_function = False
+
+                    # Store additional names for later processing
+                    self.additional_function_names = func_names[1:] if len(func_names) > 1 else []
+                    return
+
+        # For single-line functions without braces, end at newline
+        elif token == '\n' and not self.in_braced_function:
+            self._end_current_function()
+
+    def _end_current_function(self):
+        """End the current function and reset state."""
+        # Check if this might be a right assignment case
+        # We need to temporarily not end the function to see if there's a right assignment
+        self._state = self._check_right_assignment
+        self.brace_count = 0
+        self.in_braced_function = False
+
+    def _check_right_assignment(self, token):
+        """Check if there's a right assignment after function end."""
+        # Skip whitespace and comments
+        if token.isspace() or token == '\n' or token.startswith('#'):
+            return
+
+        # Look for right assignment operator
+        if token == '->':
+            self._state = self._read_right_assignment_name
+            return
+
+        # If we encounter anything else, this is not a right assignment
+        # End the function and create additional functions for multiple assignments
+        self._finalize_function_with_multiple_assignments()
+        self._state = self._state_global
+        self._state_global(token)
+
+    def _finalize_function_with_multiple_assignments(self):
+        """End the current function and create additional functions for multiple assignments."""
+        # Get the current function's information before ending it
+        current_func = self.context.current_function
+
+        # End the current function
+        self.context.end_of_function()
+
+        # Create additional function entries for multiple assignments
+        if self.additional_function_names and current_func:
+            for func_name in self.additional_function_names:
+                # Create a new function with the same complexity and line info
+                self.context.restart_new_function(func_name)
+                # Copy the complexity from the original function
+                if hasattr(current_func, 'cyclomatic_complexity'):
+                    self.context.current_function.cyclomatic_complexity = current_func.cyclomatic_complexity
+                # Set the same line range
+                self.context.current_function.start_line = current_func.start_line
+                self.context.current_function.end_line = current_func.end_line
+                # End this function immediately
+                self.context.end_of_function()
+
+        # Clear the additional names
+        self.additional_function_names = []
+
+    def _read_right_assignment_name(self, token):
+        """Read the function name after right assignment operator."""
+        # Skip whitespace
+        if token.isspace() or token == '\n':
+            return
+
+        # This should be the function name
+        if token.replace('_', 'a').replace('.', 'a').isalnum() or token == '.':
+            # Update the current function's name
+            if self.context.current_function:
+                self.context.current_function.name = token
+
+            # End the function and create additional functions for multiple assignments
+            self._finalize_function_with_multiple_assignments()
+            self._state = self._state_global
+            return
+
+        # If we get something unexpected, treat as anonymous function
+        self._finalize_function_with_multiple_assignments()
+        self._state = self._state_global
+        self._state_global(token)
+
+    def statemachine_before_return(self):
+        """Called when processing is complete - end any open functions."""
+        if self._state in [self._function_body, self._check_right_assignment, self._read_right_assignment_name]:
+            # End any open function and process multiple assignments
+            if hasattr(self.context, 'current_function') and self.context.current_function:
+                self._finalize_function_with_multiple_assignments()

lizard_languages/rust.py

@@ -19,6 +19,11 @@ class RustReader(CodeReader, CCppCommentsMixin):
         super().__init__(context)
         self.parallel_states = [RustStates(context)]
 
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        addition = r"|(?:'\w+\b)"  # lifetimes, labels
+        return CodeReader.generate_tokens(source_code, addition, token_class)
+
 
 class RustStates(GoLikeStates):  # pylint: disable=R0903
     FUNC_KEYWORD = 'fn'