lizard 1.17.12__py2.py3-none-any.whl → 1.17.14__py2.py3-none-any.whl

{lizard-1.17.12.dist-info → lizard-1.17.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.12
+Version: 1.17.14
 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/
@@ -28,6 +28,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 License-File: LICENSE.txt
+Requires-Dist: pygments
 
 |Web Site| Lizard
 =================
@@ -52,7 +53,7 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
 -  Objective-C
 -  Swift
 -  Python
@@ -68,6 +69,7 @@ A list of supported languages:
 -  Kotlin
 -  Solidity
 -  Erlang
+-  Zig
 
 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
@@ -385,5 +387,3 @@ 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.12.dist-info → lizard-1.17.14.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lizard.py,sha256=KR3F6F-5GzGQP0GLxjWmpRRUsLbfL-Lthtz3jWLlyPY,38576
+lizard.py,sha256=WfzR6yEkclgbV2CTpDZrwWDnmNUnXyd6BIL6LR--QWk,38609
 lizard_ext/__init__.py,sha256=Cz0pvH6QHyadK-rAeeEhQVsm0hW5M-fBQgV4FBaX9zk,500
 lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
 lizard_ext/csvoutput.py,sha256=IGTGICiK_IJcldRGDhd_jNDohxFWJEWYOVxkemaY20Q,3051
@@ -25,26 +25,27 @@ 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=vHwwcIFibVozQB9PB9t8W0GArqtRDBM3HzpcDelMWq8,182
+lizard_ext/version.py,sha256=Q_IWUX-GJQsIg-nJXStY9pJaspkNNkBE5mLUB-v3UKw,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=iIbCcjN1AzmVtqCB7caRcLWQ4CdQwyT0UAiRKCkVeL0,1273
-lizard_languages/clike.py,sha256=YgB0dHYdQ5Ae1pN00zcstkuXl94n8Ugo-aTYUNmJr7o,10723
-lizard_languages/code_reader.py,sha256=KTZ7v2MtaowH118yS2sd5GKgUW3hkLWUZ8YBiX3ZsL8,6180
+lizard_languages/__init__.py,sha256=PsUTjwesQ_Kk2SLsaI2Sn7ePtWLEQs2XW6EOPJJybcA,1427
+lizard_languages/clike.py,sha256=Lnwkma-jEu8FNVEPqTAKPkz1Hi0T_dP7H9Jyq0Bd0kQ,10725
+lizard_languages/code_reader.py,sha256=sMkHfIjZTom3d5gINfm42vUY28kTOOdxEUboc7eRMUU,6211
 lizard_languages/csharp.py,sha256=lVi-g-0JjHagqDR5r-lRdi2BuCdtR5aer9CYY-Nzw44,478
-lizard_languages/erlang.py,sha256=AaPfIGq_phVi2hRUVHNrrmXiQSdlEktbSVOvPxORWf8,3822
-lizard_languages/fortran.py,sha256=iXxS44sNJ2_h-nvJC58Pz6AGDyVx2HdBEVF-EeYGn84,7327
+lizard_languages/erlang.py,sha256=7YJS2cMyXDKEV_kpH8DzBARxFCFcjKuTOPSQ3K52auU,3860
+lizard_languages/fortran.py,sha256=KATDsnfjob5W3579A_VxbwrbTkK7Rx3p0eXdBgjx25I,8973
 lizard_languages/gdscript.py,sha256=KwlGoODilQnFgXvODpq_XlA6fV3hGbN9fd7bsiEUn78,637
 lizard_languages/go.py,sha256=dSbWxtWve7KSRW5i9w4DxhODtJ72EcBNrgp-7Xhn0Sg,465
 lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
 lizard_languages/java.py,sha256=mfXCRicmZFZFxPW7QuTOQtAKzOZD3d-uh4tiALcGdX4,1186
-lizard_languages/javascript.py,sha256=agcEwJbrY0tFt8rGWwsO2pH-MKXvKmt9BMlcKkUB9m4,4314
+lizard_languages/javascript.py,sha256=dc_P3fS39S-5sefTNKPzi7Hype7WkM3rMKONpd1iklM,4143
 lizard_languages/js_style_language_states.py,sha256=2_dgrXLe113xEdfATByioohGquW428pPo9gI3I1duS4,4257
 lizard_languages/js_style_regex_expression.py,sha256=1d4eK5RR0GBAFg2eDb2cKA_YHIYlxjhG7PXAuMOKnRA,743
+lizard_languages/jsx.py,sha256=trMT1ruo6Wi3kJB0qQYJL8Ms0GFEapqD9_SaTe0vCDk,785
 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/php.py,sha256=8OufyR2TIWyf3bXuTmp37Vwf_tEPF4YV5M3i5_jnguA,1377
-lizard_languages/python.py,sha256=JDXqQ7SEnNSXlbK5sMyUKwCFBTEto20Wg8_ZkzYisSI,3721
+lizard_languages/python.py,sha256=5MwhyuzUqbUkhNyzeo_YsTRp4onMUVC19t61lLnDyjc,3761
 lizard_languages/ruby.py,sha256=gUrFsaS6ZJbjb9CixBHP9n0BxGOb8HsDEg7jJ2bz_80,2187
 lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
 lizard_languages/rust.py,sha256=DG2RkR9JWwcD6gIw-BPzg-Yo_lxQtSvfgHioFWIQm9o,610
@@ -53,11 +54,13 @@ lizard_languages/script_language.py,sha256=FOzB9Rg5-XTnFDeeRRyIrp2rDomRDHhaPsxsx
 lizard_languages/solidity.py,sha256=Z0GD7U5bI5eUikdy7m_iKWeFD5yXRYq4r3zycscOhJQ,553
 lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,2450
 lizard_languages/tnsdl.py,sha256=pGcalA_lHY362v2wwPS86seYBOOBBjvmU6vd4Yy3A9g,2803
+lizard_languages/tsx.py,sha256=Ey7IxFfF2nwt-MJisEO2FaIOl47m4EPf3jF6x62YTVA,1332
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=yjUTVDkiONbg2v089pZC4wrCJSo1J5NVbQzbCfF4k6s,1547
-lizard-1.17.12.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.12.dist-info/METADATA,sha256=449xh2XT8PSdqHs1N-nAQVoyKRFp7bYdJGtUNVK5SMc,15379
-lizard-1.17.12.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
-lizard-1.17.12.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.17.12.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.12.dist-info/RECORD,,
+lizard_languages/typescript.py,sha256=fyJeimadxFXqtfTt8MyVzAg6XqpVZeFJ1qp8RGurXbk,2594
+lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
+lizard-1.17.14.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.14.dist-info/METADATA,sha256=RhLjrf5029-qdpfH3yGvH35sEaktWyHVmypIZHzhniA,15419
+lizard-1.17.14.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.14.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.14.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.14.dist-info/RECORD,,

{lizard-1.17.12.dist-info → lizard-1.17.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

{lizard-1.17.12.dist-info → lizard-1.17.14.dist-info}/entry_points.txt

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

lizard.py

@@ -572,7 +572,9 @@ class FileAnalyzer(object):  # pylint: disable=R0903
             for _ in reader(tokens, reader):
                 pass
         except RecursionError as e:
-            sys.stderr.write("[skip] fail to process '%s' with RecursionError - %s\n" % (filename, e))
+            sys.stderr.write(
+                "[skip] fail to process '%s' with RecursionError - %s\n" %
+                (filename, e))
         return context.fileinfo
 
 

lizard_ext/version.py

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

lizard_languages/__init__.py

@@ -1,5 +1,6 @@
 ''' programming languages of lizard '''
 
+from lizard_languages.zig import ZigReader
 from .clike import CLikeReader
 from .erlang import ErlangReader
 from .java import JavaReader
@@ -20,6 +21,8 @@ from .rust import RustReader
 from .typescript import TypeScriptReader
 from .fortran import FortranReader
 from .solidity import SolidityReader
+from .jsx import JSXReader
+from .tsx import TSXReader
 
 
 def languages():
@@ -44,6 +47,9 @@ def languages():
         KotlinReader,
         SolidityReader,
         ErlangReader,
+        ZigReader,
+        JSXReader,
+        TSXReader,
     ]
 
 

lizard_languages/clike.py

@@ -182,7 +182,7 @@ class CLikeStates(CodeStateMachine):
             self.context.add_to_function_name(' ' + token)
 
     def _state_name_with_space(self, token):
-        self._state = self._state_operator\
+        self._state = self._state_operator \
             if token == 'operator' else self._state_function
         self.context.add_to_function_name(token)
 
@@ -196,7 +196,7 @@ class CLikeStates(CodeStateMachine):
             else:
                 self.next(self._state_global)
         elif len(self.bracket_stack) == 1:
-            if token != 'void': # void is a reserved keyword, meaning no parameters
+            if token != 'void':  # void is a reserved keyword, meaning no parameters
                 self.context.parameter(token)
             return
         self.context.add_to_long_function_name(token)

lizard_languages/code_reader.py

@@ -114,14 +114,16 @@ class CodeReader:
         if not token_class:
             token_class = create_token
 
-        def _generate_tokens(source, add, flags=re.NOFLAG):
+        def _generate_tokens(source, add, flags=0):
             # DO NOT put any sub groups in the regex. Good for performance
             _until_end = r"(?:\\\n|[^\n])*"
-            combined_symbols = ["<<=", ">>=", "||", "&&", "===", "!==",
-                                "==", "!=", "<=", ">=", "->", "=>",
-                                "++", "--", '+=', '-=',
-                                "+", "-", '*', '/',
-                                '*=', '/=', '^=', '&=', '|=', "..."]
+            combined_symbols = [
+                "<<=", ">>=", "||", "&&", "===", "!==",
+                "==", "!=", "<=", ">=", "->", "=>",
+                "++", "--", '+=', '-=',
+                "+", "-", '*', '/',
+                '*=', '/=', '^=', '&=', '|=', "..."
+            ]
             token_pattern = re.compile(
                 r"(?:" +
                 r"\/\*.*?\*\/" +
@@ -170,9 +172,13 @@ class CodeReader:
 
         pattern = re.compile(r'\(\?[aiLmsux]+\)')
         re_flags = ''.join(opt[2:-1] for opt in pattern.findall(addition))
-        flags = reduce(or_, (flag_dict[flag] for flag in re_flags), re.NOFLAG)
+        flags = reduce(or_, (flag_dict[flag] for flag in re_flags), 0)
+        cleaned_addition = pattern.sub('', addition)
 
-        return _generate_tokens(source_code, pattern.sub('', addition), flags=flags)
+        return _generate_tokens(
+            source_code,
+            cleaned_addition,
+            flags=flags)
 
     def __call__(self, tokens, reader):
         self.context = reader.context

lizard_languages/erlang.py

@@ -26,8 +26,12 @@ class ErlangReader(CodeReader):
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
-        return map(lambda x: x[1], filter(lambda x: x[0] != py_token.Whitespace,
-                                          lex(source_code, lexer=lexers.get_lexer_by_name('erlang'))))
+        lexer = lexers.get_lexer_by_name('erlang')
+        tokens = lex(source_code, lexer=lexer)
+        return map(
+            lambda x: x[1],
+            filter(lambda x: x[0] != py_token.Whitespace, tokens)
+        )
 
 
 class ErlangStates(CodeStateMachine):
@@ -77,8 +81,8 @@ class ErlangStates(CodeStateMachine):
         if token == '-':
             self.punctuated = True
         elif token == '>' and self.punctuated:
-            if len(self.context.stacked_functions) <= 1 or \
-                    self.context.current_function.name == 'fun':
+            if (len(self.context.stacked_functions) <= 1 or
+                    self.context.current_function.name == 'fun'):
                 self.next(self._state_func_first_line, token)
         else:
             self.func_match_failed(token)
@@ -93,8 +97,8 @@ class ErlangStates(CodeStateMachine):
 
     def _state_nested_end(self, token):
         if token == '.' or token == ',':
-            if len(self.context.stacked_functions) > 1 \
-                    and self.context.stacked_functions[-1].name == 'fun':
+            if (len(self.context.stacked_functions) > 1 and
+                    self.context.stacked_functions[-1].name == 'fun'):
                 self.statemachine_return()
                 return
 

lizard_languages/fortran.py

@@ -6,57 +6,65 @@ import re
 from .code_reader import CodeStateMachine, CodeReader
 
 
-# pylint: disable=R0903
-class FortranCommentsMixin(object):
+class FortranCommentsMixin:
     @staticmethod
     def get_comment_from_token(token):
         if token.startswith('!'):
             return token[1:]
 
 
-# pylint: disable=R0903
 class FortranReader(CodeReader, FortranCommentsMixin):
-    ''' This is the reader for Fortran. '''
+    '''This is the reader for Fortran.'''
 
     ext = ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
     language_names = ['fortran']
-    _conditions = set((
+
+    # 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'))
-    _blocks = ['PROGRAM', 'MODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE', 'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE']
+        'if', 'do', '.and.', '.or.', 'case'
+    }
+    _blocks = [
+        'PROGRAM', 'MODULE', 'SUBMODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE',
+        'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE'
+    ]
 
     def __init__(self, context):
-        super(FortranReader, self).__init__(context)
+        super().__init__(context)
         self.macro_disabled = False
         self.parallel_states = [FortranStates(context, self)]
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
         _until_end = r'(?:\\\n|[^\n])*'
-        return CodeReader.generate_tokens(
-            source_code,
+        block_endings = '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)
+        # Include all patterns and the (?i) flag in addition
+        addition = (
             r'(?i)'
-            r'\/\/' +
-            r'|\#' + _until_end +
-            r'|\!' + _until_end +
-            r'|^\*' + _until_end +
-            r'|\.OR\.' +
-            r'|\.AND\.' +
-            r'|ELSE +IF' +
-            ''.join(r'|END[ \t]+{0}'.format(_) for _ in FortranReader._blocks) +
-            addition,
-            token_class)
+            r'\/\/|'
+            r'\#' + _until_end + r'|'
+            r'\!' + _until_end + r'|'
+            r'^\*' + _until_end + r'|'
+            r'\.OR\.|'
+            r'\.AND\.|'
+            r'ELSE\s+IF|'
+            r'MODULE\s+PROCEDURE|'
+            + block_endings + addition
+        )
+        return CodeReader.generate_tokens(
+            source_code, addition=addition, token_class=token_class)
 
     def preprocess(self, tokens):
         macro_depth = 0
         new_line = True
         for token in tokens:
-            if new_line and token[0].upper() in ('c', 'C', '*'):
-                token = '!'+token[1:]
+            if new_line and token[0].upper() in ('C', '*'):
+                token = '!' + token[1:]
             new_line = token == '\n'
-            macro = re.match(r'#\s*(\w+)', token)
-            if macro:
-                macro = macro.group(1).lower()
+            macro_match = re.match(r'#\s*(\w+)', token)
+            if macro_match:
+                macro = macro_match.group(1).lower()
                 if macro in ('if', 'ifdef', 'ifndef', 'elif'):
                     self.context.add_condition()
                 if macro_depth > 0:
@@ -66,22 +74,29 @@ class FortranReader(CodeReader, FortranCommentsMixin):
                         macro_depth -= 1
                 elif macro in ('else', 'elif'):
                     macro_depth += 1
-                # In order to don't mess the nesting,
-                # only the first branch of #if #elif #else
-                # is read by the FortranStateMachine
+                # Only the first branch of #if #elif #else is read
                 self.macro_disabled = macro_depth != 0
             elif not token.isspace() or token == '\n':
                 yield token
 
-# pylint: disable=R0903
+
 class FortranStates(CodeStateMachine):
-    # pylint: disable=line-too-long
-    # pylint: disable=protected-access
-    _ends = re.compile('(?:'+'|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)+')', re.I)
+    _ends = re.compile(
+        '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks), re.I)
+
+    # Define token groups to eliminate duplication
+    IGNORE_NEXT_TOKENS = {'%', '::', 'SAVE', 'DATA'}
+    IGNORE_VAR_TOKENS = {'INTEGER', 'REAL', 'COMPLEX', 'LOGICAL', 'CHARACTER'}
+    RESET_STATE_TOKENS = {'RECURSIVE', 'ELEMENTAL'}
+    FUNCTION_NAME_TOKENS = {'SUBROUTINE', 'FUNCTION'}
+    NESTING_KEYWORDS = {'FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'}
+    PROCEDURE_TOKENS = {'PROCEDURE', 'MODULE PROCEDURE'}
 
     def __init__(self, context, reader):
-        super(FortranStates, self).__init__(context)
+        super().__init__(context)
         self.reader = reader
+        self.last_token = None
+        self.in_interface = False
 
     def __call__(self, token, reader=None):
         if self.reader.macro_disabled:
@@ -96,28 +111,35 @@ class FortranStates(CodeStateMachine):
 
     def _state_global(self, token):
         token_upper = token.upper()
-        if token_upper in ('%', '::', 'SAVE', 'DATA'):
+        if token_upper in self.IGNORE_NEXT_TOKENS:
             self._state = self._ignore_next
-        elif token_upper in ('INTEGER', 'REAL','COMPLEX','LOGICAL', 'CHARACTER'):
+        elif token_upper in self.IGNORE_VAR_TOKENS:
             self._state = self._ignore_var
         elif token == '(':
             self.next(self._ignore_expr, token)
-        elif token_upper in ('PROGRAM',):
+        elif token_upper in self.RESET_STATE_TOKENS:
+            self.reset_state()
+        elif token_upper in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token_upper == 'PROGRAM':
             self._state = self._namespace
         elif token_upper == 'MODULE':
+            self._state = self._module_or_procedure
+        elif token_upper == 'SUBMODULE':
             self._state = self._module
-        elif token_upper in ('SUBROUTINE', 'FUNCTION'):
-            self._state = self._function_name
+            self._module(token)
         elif token_upper == 'TYPE':
             self._state = self._type
         elif token_upper == 'IF':
             self._state = self._if
-        elif token_upper in ('BLOCK',):
+        elif token_upper == 'BLOCK':
             self._state = self._ignore_if_paren
-        elif token_upper in ('DO',):
+        elif token_upper == 'DO':
             self._state = self._ignore_if_label
-        elif token_upper in ('FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'):
+        elif token_upper in self.NESTING_KEYWORDS:
             self.context.add_bare_nesting()
+            if token_upper == 'INTERFACE':
+                self.in_interface = True
         elif token_upper == 'ELSE':
             self.context.pop_nesting()
             self.context.add_bare_nesting()
@@ -127,6 +149,9 @@ class FortranStates(CodeStateMachine):
                 self.context.add_condition()
             self._state = self._if
         elif token_upper == 'END' or self._ends.match(token):
+            end_token_upper = token_upper.replace(' ', '')
+            if end_token_upper.startswith('ENDINTERFACE'):
+                self.in_interface = False
             self.context.pop_nesting()
 
     def reset_state(self, token=None):
@@ -134,12 +159,11 @@ class FortranStates(CodeStateMachine):
         if token is not None:
             self._state_global(token)
 
-    # pylint: disable=unused-argument
     def _ignore_next(self, token):
         self.reset_state()
 
     def _ignore_var(self, token):
-        if token.upper() in ('SUBROUTINE', 'FUNCTION'):
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
             self.reset_state(token)
         else:
             self.reset_state()
@@ -152,7 +176,7 @@ class FortranStates(CodeStateMachine):
             self.reset_state()
 
     def _ignore_if_label(self, token):
-        if all(char in "0123456789" for char in token):
+        if token.isdigit():
             self.reset_state()
         else:
             self.context.add_bare_nesting()
@@ -184,11 +208,24 @@ class FortranStates(CodeStateMachine):
         self.reset_state(token)
 
     def _module(self, token):
-        if token.upper() == 'PROCEDURE':
-            self.reset_state()
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token.upper() in self.PROCEDURE_TOKENS:
+            self._state = self._procedure
         else:
             self._namespace(token)
 
+    def _procedure(self, token):
+        # Start a new function regardless of context
+        if self.last_token and self.last_token.upper() == 'MODULE':
+            # For "module procedure" case, use the current token as function name
+            self.context.restart_new_function(token)
+        else:
+            # For standalone "procedure" case
+            self.context.restart_new_function(token)
+        self.context.add_bare_nesting()
+        self.reset_state()
+
     def _type(self, token):
         if token in (',', '::') or token[0].isalpha():
             self._namespace(token)
@@ -210,8 +247,15 @@ class FortranStates(CodeStateMachine):
         pass
 
     def _if_then(self, token):
-        if token.upper() == 'THEN':
+        token_upper = token.upper()
+        if token_upper == 'THEN':
             self.context.add_bare_nesting()
             self.reset_state()
         else:
             self.reset_state(token)
+
+    def _module_or_procedure(self, token):
+        if token.upper() == 'PROCEDURE':
+            self._state = self._procedure
+        else:
+            self._module(token)

lizard_languages/javascript.py

@@ -11,7 +11,7 @@ from .js_style_language_states import JavaScriptStyleLanguageStates
 class JavaScriptReader(CodeReader, CCppCommentsMixin):
     # pylint: disable=R0903
 
-    ext = ['js', 'jsx']
+    ext = ['js']
     language_names = ['javascript', 'js']
 
     @staticmethod
@@ -19,7 +19,6 @@ class JavaScriptReader(CodeReader, CCppCommentsMixin):
     def generate_tokens(source_code, addition='', token_class=None):
         addition = addition +\
             r"|(?:\$\w+)" + \
-            r"|(?:\<\/\w+\>)" + \
             r"|`.*?`"
         js_tokenizer = JSTokenizer()
         for token in CodeReader.generate_tokens(
@@ -69,9 +68,6 @@ class JSTokenizer(Tokenizer):
             self.depth -= 1
             if self.depth == 0:
                 self.stop()
-                # {} in JSX is not listed as token
-                # otherwise it will be regarded
-                # as JS object
                 return
         yield token
 

lizard_languages/jsx.py

@@ -0,0 +1,27 @@
+'''
+Language parser for JSX
+'''
+
+from .javascript import JavaScriptReader, JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
+from .code_reader import CodeReader
+from .js_style_regex_expression import js_style_regex_expression
+
+
+class JSXReader(JavaScriptReader):
+    # pylint: disable=R0903
+
+    ext = ['jsx']
+    language_names = ['jsx']
+
+    @staticmethod
+    @js_style_regex_expression
+    def generate_tokens(source_code, addition='', token_class=None):
+        addition = addition +\
+            r"|(?:\$\w+)" + \
+            r"|(?:\<\/\w+\>)" + \
+            r"|`.*?`"
+        js_tokenizer = JSTokenizer()
+        for token in CodeReader.generate_tokens(
+                source_code, addition, token_class):
+            for tok in js_tokenizer(token):
+                yield tok

lizard_languages/python.py

@@ -13,7 +13,7 @@ class PythonIndents:  # pylint: disable=R0902
         self.indents = [0]
         self.context = context
 
-    def set_nesting(self, spaces, token = ""):
+    def set_nesting(self, spaces, token=""):
         while self.indents[-1] > spaces and (not token.startswith(")")):
             self.indents.pop()
             self.context.pop_nesting()
@@ -29,8 +29,10 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['py']
     language_names = ['python']
-    _conditions = set(['if', 'for', 'while', 'and', 'or',
-                      'elif', 'except', 'finally'])
+    _conditions = set([
+        'if', 'for', 'while', 'and', 'or',
+        'elif', 'except', 'finally'
+    ])
 
     def __init__(self, context):
         super(PythonReader, self).__init__(context)
@@ -39,8 +41,9 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
         return ScriptLanguageMixIn.generate_common_tokens(
-                source_code,
-                r"|\'\'\'.*?\'\'\'" + r'|\"\"\".*?\"\"\"', token_class)
+            source_code,
+            r"|\'\'\'.*?\'\'\'" + r'|\"\"\".*?\"\"\"',
+            token_class)
 
     def preprocess(self, tokens):
         indents = PythonIndents(self.context)
@@ -54,7 +57,8 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
                     else:
                         if not token.startswith('#'):
                             current_function = self.context.current_function
-                            if current_function.name == '*global*' or current_function.long_name.endswith(')'):
+                            if (current_function.name == '*global*' or
+                                    current_function.long_name.endswith(')')):
                                 indents.set_nesting(current_leading_spaces, token)
                         reading_leading_space = False
             else:

lizard_languages/tsx.py

@@ -0,0 +1,44 @@
+'''
+Language parser for TSX
+'''
+
+from .typescript import TypeScriptReader, TypeScriptStates
+from .javascript import JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
+from .code_reader import CodeReader
+from .js_style_regex_expression import js_style_regex_expression
+
+
+class TSXReader(TypeScriptReader):
+    # pylint: disable=R0903
+
+    ext = ['tsx']
+    language_names = ['tsx']
+
+    @staticmethod
+    @js_style_regex_expression
+    def generate_tokens(source_code, addition='', token_class=None):
+        addition = addition +\
+            r"|(?:\$\w+)" + \
+            r"|(?:\<\/\w+\>)" + \
+            r"|`.*?`"
+        js_tokenizer = JSTokenizer()
+        for token in CodeReader.generate_tokens(
+                source_code, addition, token_class):
+            for tok in js_tokenizer(token):
+                yield tok
+
+    def __init__(self, context):
+        super(TSXReader, self).__init__(context)
+        self.parallel_states = [TSXStates(context)]
+
+
+class TSXStates(TypeScriptStates):
+    def _expecting_func_opening_bracket(self, token):
+        if token == '<':
+            self.next(self._expecting_jsx)
+            return
+        super(TSXStates, self)._expecting_func_opening_bracket(token)
+
+    def _expecting_jsx(self, token):
+        if token == '>':
+            self.next(self._expecting_func_opening_bracket) 

lizard_languages/typescript.py

@@ -31,6 +31,30 @@ class TypeScriptReader(CodeReader, CCppCommentsMixin):
 
 class TypeScriptStates(JavaScriptStyleLanguageStates):
 
+    def _state_global(self, token):
+        if token == ':':
+            # When we see a type annotation in global state, store the last tokens
+            # but don't treat it as a function name yet
+            self._potential_name = self.last_tokens
+            self.next(self._type_annotation)
+            return
+        if token == '=>':
+            # For arrow functions, we want to treat them as anonymous
+            self.function_name = ''
+            self._state = self._arrow_function
+            return
+        super(TypeScriptStates, self)._state_global(token)
+
+    def _type_annotation(self, token):
+        if token == '=':
+            # We're back to an assignment, restore the potential name
+            if hasattr(self, '_potential_name'):
+                self.last_tokens = self._potential_name
+                delattr(self, '_potential_name')
+            self.next(self._state_global, token)
+        else:
+            self.next(self._type_annotation)
+
     def _expecting_func_opening_bracket(self, token):
         if token == ':':
             self.next(self._expecting_default)
@@ -47,3 +71,5 @@ class TypeScriptStates(JavaScriptStyleLanguageStates):
             self.next(self._state_global)
         elif token == '{':
             self.next(self._expecting_func_opening_bracket, token)
+        elif token == '=':
+            self.next(self._state_global, token)

lizard_languages/zig.py

@@ -0,0 +1,25 @@
+"""
+Language parser for Zig
+"""
+
+from __future__ import annotations
+
+from .clike import CCppCommentsMixin
+from .code_reader import CodeReader
+from .golike import GoLikeStates
+
+
+class ZigReader(CodeReader, CCppCommentsMixin):
+    ext = ["zig"]
+    language_names = ["zig"]
+    _conditions = {"if", "for", "while", "and", "or", "orelse", "try", "catch", "=>"}
+
+    def __init__(self, context):
+        super().__init__(context)
+        self.parallel_states = [ZigStates(context)]
+
+
+class ZigStates(GoLikeStates):
+    FUNC_KEYWORD = "fn"
+
+    _type_definition = GoLikeStates._state_global