lizard 1.17.13__tar.gz → 1.17.14__tar.gz

{lizard-1.17.13 → lizard-1.17.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.13
+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/
@@ -52,7 +52,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 +68,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 +386,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.13 → lizard-1.17.14}/README.rst

@@ -21,7 +21,7 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
 -  Objective-C
 -  Swift
 -  Python
@@ -37,6 +37,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

{lizard-1.17.13 → lizard-1.17.14}/lizard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.13
+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/
@@ -52,7 +52,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 +68,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 +386,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.13 → lizard-1.17.14}/lizard.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ lizard_languages/java.py
 lizard_languages/javascript.py
 lizard_languages/js_style_language_states.py
 lizard_languages/js_style_regex_expression.py
+lizard_languages/jsx.py
 lizard_languages/kotlin.py
 lizard_languages/lua.py
 lizard_languages/objc.py
@@ -63,8 +64,10 @@ lizard_languages/script_language.py
 lizard_languages/solidity.py
 lizard_languages/swift.py
 lizard_languages/tnsdl.py
+lizard_languages/tsx.py
 lizard_languages/ttcn.py
 lizard_languages/typescript.py
+lizard_languages/zig.py
 test/testApplication.py
 test/testAssertionExtension.py
 test/testBasicFunctionInfo.py

{lizard-1.17.13 → lizard-1.17.14}/lizard.egg-info/entry_points.txt

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

{lizard-1.17.13 → lizard-1.17.14}/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-1.17.13 → lizard-1.17.14}/lizard_ext/version.py

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

{lizard-1.17.13 → lizard-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-1.17.13 → lizard-1.17.14}/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-1.17.13 → lizard-1.17.14}/lizard_languages/code_reader.py

@@ -117,11 +117,13 @@ class CodeReader:
         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"\/\*.*?\*\/" +
@@ -171,8 +173,12 @@ 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), 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-1.17.13 → lizard-1.17.14}/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-1.17.13 → lizard-1.17.14}/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-1.17.13 → lizard-1.17.14}/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-1.17.14/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-1.17.13 → lizard-1.17.14}/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-1.17.14/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-1.17.13 → lizard-1.17.14}/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-1.17.14/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

{lizard-1.17.13 → lizard-1.17.14}/setup.cfg

@@ -4,6 +4,9 @@ universal = 1
 [tool:pytest]
 python_files = test*
 
+[pycodestyle]
+max-line-length = 120
+
 [egg_info]
 tag_build = 
 tag_date = 0

{lizard-1.17.13 → lizard-1.17.14}/test/testLanguages.py

@@ -1,6 +1,7 @@
 import unittest
 from lizard_languages import get_reader_for, CLikeReader, JavaReader, ObjCReader, JavaScriptReader, ScalaReader,\
     GDScriptReader, SolidityReader, ErlangReader
+from lizard_languages.zig import ZigReader
 
 
 class TestLanguageChooser(unittest.TestCase):
@@ -36,3 +37,6 @@ class TestLanguageChooser(unittest.TestCase):
 
     def test_erlang(self):
         self.assertEqual(ErlangReader, get_reader_for("a.erl"))
+
+    def test_zig(self):
+        self.assertEqual(ZigReader, get_reader_for("a.zig"))