cpyte 2.0.0__tar.gz → 2.0.2__tar.gz

{cpyte-2.0.0 → cpyte-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 2.0.0
+Version: 2.0.2
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -13,6 +13,46 @@ Check out the official documentation [here](https://gitea.5gnew.io.vn/duytung/Cp
 
 **Note:** Version 1.6.1 had a critical division by zero error that wasn't caught.
 
+## Package Extensions
+
+Cpyte supports a package extension system that allows packages to extend the compiler with custom keywords, operators, and compiler hooks. Packages can provide:
+
+- **Custom Keywords**: Add new language keywords via `package.json`
+- **Custom Operators**: Define new operators for syntax extensions  
+- **Compiler Hooks**: Extend lexing, parsing, semantic analysis, and code generation
+- **Runtime Extensions**: Add runtime code and libraries
+
+### Package Structure
+
+Packages are stored in `.cpm/modules/package_name/version/` and can include:
+
+- `package.json` - Extension manifest declaring capabilities
+- `parser_hooks.py` - Custom syntax extensions
+- `semantic_hooks.py` - Custom type checking and analysis rules
+- `codegen_hooks.py` - Custom LLVM IR generation
+- `runtime_hooks.py` - Runtime code and libraries
+- `*.cpy` - Main package entry point
+- `*.ll` - Prebuilt LLVM IR
+
+### Example Package
+
+See `examples/example_package/` for a complete example package with:
+- Custom keywords: `async`, `await`, `defer`
+- Custom operator: `~~`
+- Parser, semantic, codegen, and runtime hooks
+
+### Using Extension Packages
+
+```cpy
+import @package_name
+
+# Use custom keywords and syntax from the package
+async def my_function() -> Promise:
+    # Custom syntax
+    defer cleanup()
+    return result
+```
+
 ## Examples
 
 You'll find comprehensive examples in the `examples/` directory that cover C imports, header imports, 64-bit support, and standard library usage:
@@ -28,6 +68,7 @@ You'll find comprehensive examples in the `examples/` directory that cover C imp
 | `examples/mixed_features.cpy` | Combines C imports, H imports, 64-bit, structs, pointers, linked lists |
 | `examples/mixed_helpers.c` / `mixed_helpers.h` | Supporting C/header files for the mixed features example |
 | `examples/test.cpy` | macOS event tap example that intercepts keyboard events using ApplicationServices framework |
+| `examples/example_package/` | Example package demonstrating extension capabilities with custom keywords, operators, and compiler hooks |
 
 You can also import `.cpy` files — the examples show how to use `import "other.cpy"` to bring in public functions and structs from other Cpy files.
 

{cpyte-2.0.0 → cpyte-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cpyte"
-version = "2.0.0"
+version = "2.0.2"
 description = "The Cpyte programming language compiler"
 readme = "readme.md"
 requires-python = ">=3.11"

{cpyte-2.0.0 → cpyte-2.0.2}/readme.md

@@ -2,6 +2,46 @@ Check out the official documentation [here](https://gitea.5gnew.io.vn/duytung/Cp
 
 **Note:** Version 1.6.1 had a critical division by zero error that wasn't caught.
 
+## Package Extensions
+
+Cpyte supports a package extension system that allows packages to extend the compiler with custom keywords, operators, and compiler hooks. Packages can provide:
+
+- **Custom Keywords**: Add new language keywords via `package.json`
+- **Custom Operators**: Define new operators for syntax extensions  
+- **Compiler Hooks**: Extend lexing, parsing, semantic analysis, and code generation
+- **Runtime Extensions**: Add runtime code and libraries
+
+### Package Structure
+
+Packages are stored in `.cpm/modules/package_name/version/` and can include:
+
+- `package.json` - Extension manifest declaring capabilities
+- `parser_hooks.py` - Custom syntax extensions
+- `semantic_hooks.py` - Custom type checking and analysis rules
+- `codegen_hooks.py` - Custom LLVM IR generation
+- `runtime_hooks.py` - Runtime code and libraries
+- `*.cpy` - Main package entry point
+- `*.ll` - Prebuilt LLVM IR
+
+### Example Package
+
+See `examples/example_package/` for a complete example package with:
+- Custom keywords: `async`, `await`, `defer`
+- Custom operator: `~~`
+- Parser, semantic, codegen, and runtime hooks
+
+### Using Extension Packages
+
+```cpy
+import @package_name
+
+# Use custom keywords and syntax from the package
+async def my_function() -> Promise:
+    # Custom syntax
+    defer cleanup()
+    return result
+```
+
 ## Examples
 
 You'll find comprehensive examples in the `examples/` directory that cover C imports, header imports, 64-bit support, and standard library usage:
@@ -17,6 +57,7 @@ You'll find comprehensive examples in the `examples/` directory that cover C imp
 | `examples/mixed_features.cpy` | Combines C imports, H imports, 64-bit, structs, pointers, linked lists |
 | `examples/mixed_helpers.c` / `mixed_helpers.h` | Supporting C/header files for the mixed features example |
 | `examples/test.cpy` | macOS event tap example that intercepts keyboard events using ApplicationServices framework |
+| `examples/example_package/` | Example package demonstrating extension capabilities with custom keywords, operators, and compiler hooks |
 
 You can also import `.cpy` files — the examples show how to use `import "other.cpy"` to bring in public functions and structs from other Cpy files.
 

{cpyte-2.0.0 → cpyte-2.0.2}/source/cpyte/astparse.py

@@ -1,4 +1,40 @@
 from .lexar import Token, TokenType
+from typing import Optional, Dict, Any, List
+
+
+_parser_hooks: List[Any] = []
+
+
+def register_parser_hook(hook: Any) -> None:
+    _parser_hooks.append(hook)
+
+
+def unregister_parser_hook(hook: Any) -> None:
+    if hook in _parser_hooks:
+        _parser_hooks.remove(hook)
+
+
+def get_parser_hooks() -> List[Any]:
+    return _parser_hooks.copy()
+
+
+def clear_parser_hooks() -> None:
+    _parser_hooks.clear()
+
+
+def _get_all_parser_hooks(enable_extensions: bool) -> List[Any]:
+    if not enable_extensions:
+        return []
+    hooks = list(_parser_hooks)
+    try:
+        from .extension_hooks import get_global_hook_registry
+        registry = get_global_hook_registry()
+        for hook in registry.get_parser_hooks():
+            if hook not in hooks:
+                hooks.append(hook)
+    except ImportError:
+        pass
+    return hooks
 
 
 def parse_f(tree: list[Token]):
@@ -45,7 +81,7 @@ class Number:
         return f'Number({self.value})'
 
 class String:
-    __slots__ = ('value', '_token')
+    __slots__ = ('value', '_token', 'inferred_type')
     def __init__(self, value: str, token=None):
         self.value = value
         self._token = token
@@ -53,7 +89,7 @@ class String:
         return f'String({self.value})'
 
 class Variable:
-    __slots__ = ('name', '_token', 'const_value')
+    __slots__ = ('name', '_token', 'const_value', 'inferred_type')
     def __init__(self, name: str, token=None):
         self.name = name
         self._token = token
@@ -263,6 +299,9 @@ def _parse_atom(tokens: list[Token], pos: int):
             pos += 1
         return NewExpr(type_str, size, token=tok), pos
 
+    if tok.type == TokenType.KEYWORD and tok.value == 'asm':
+        return parse_inline_asm(tokens, pos)
+
     if tok.type == TokenType.KEYWORD and tok.value == 'sizeof':
         pos += 1
         if pos >= len(tokens) or tokens[pos].type != TokenType.LPAREN:
@@ -321,7 +360,7 @@ def _parse_postfix(tokens: list[Token], pos: int, node):
     return node, pos
 
 
-def parse_file(tokens: list[Token], pos: int = 0):
+def parse_file(tokens: list[Token], pos: int = 0, enable_extensions: bool = True):
     nodes = []
     while pos < len(tokens) and tokens[pos].type not in (TokenType.EOF, TokenType.DEDENT):
         while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
@@ -331,55 +370,79 @@ def parse_file(tokens: list[Token], pos: int = 0):
             break
 
         tok = tokens[pos]
-        if tok.type == TokenType.KEYWORD and tok.value == 'def':
-            node, pos = parse_def(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value in ('public', 'private', 'static', 'virtual', 'override'):
-            node, pos = parse_decorated_def(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'class':
-            node, pos = parse_class(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'struct':
-            node, pos = parse_struct_def(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'if':
-            node, pos = parse_if(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'return':
-            node, pos = parse_return(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'while':
-            node, pos = parse_while(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'for':
-            node, pos = parse_for(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'import':
-            node, pos = parse_import(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'print':
-            node, pos = parse_print(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'break':
-            node, pos = parse_break(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'continue':
-            node, pos = parse_continue(tokens, pos)
-        elif tok.type == TokenType.KEYWORD and tok.value == 'switch':
-            node, pos = parse_switch(tokens, pos)
-        elif tok.type == TokenType.IDENTIFIER and pos + 1 < len(tokens):
-            if tok.value in _TYPE_NAMES or _looks_like_type(tokens, pos):
+        
+        all_hooks = _get_all_parser_hooks(enable_extensions)
+        if all_hooks:
+            handled = False
+            for hook in all_hooks:
                 try:
-                    save = pos
-                    node, pos = parse_var_decl(tokens, pos)
-                    if node is not None:
+                    if hasattr(hook, 'should_handle_statement') and hook.should_handle_statement(tokens, pos):
+                        node, pos = hook.parse_statement(tokens, pos, {'tokens': tokens, 'pos': pos})
                         nodes.append(node)
-                        while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
-                            pos += 1
-                        continue
-                except ParseError:
-                    pos = save
-            node, pos = parse_expr_stmt(tokens, pos)
+                        handled = True
+                        break
+                except Exception:
+                    pass
+            if not handled:
+                node, pos = _parse_standard_statement(tokens, pos)
+                nodes.append(node)
         else:
-            node, pos = parse_expr_stmt(tokens, pos)
-
-        if node is not None:
+            node, pos = _parse_standard_statement(tokens, pos)
             nodes.append(node)
+    
+    return nodes, pos
 
-        while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
-            pos += 1
 
-    return nodes, pos
+def _parse_standard_statement(tokens: list[Token], pos: int):
+    """Parse a statement using standard grammar (non-hooked)."""
+    tok = tokens[pos]
+    if tok.type == TokenType.KEYWORD and tok.value == 'def':
+        node, pos = parse_def(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value in ('public', 'private', 'static', 'virtual', 'override'):
+        node, pos = parse_decorated_def(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'class':
+        node, pos = parse_class(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'struct':
+        node, pos = parse_struct_def(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'if':
+        node, pos = parse_if(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'return':
+        node, pos = parse_return(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'while':
+        node, pos = parse_while(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'for':
+        node, pos = parse_for(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'import':
+        node, pos = parse_import(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'print':
+        node, pos = parse_print(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'break':
+        node, pos = parse_break(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'continue':
+        node, pos = parse_continue(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'switch':
+        node, pos = parse_switch(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'try':
+        node, pos = parse_try(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == 'raise':
+        node, pos = parse_raise(tokens, pos)
+    elif tok.type == TokenType.IDENTIFIER and pos + 1 < len(tokens):
+        if tok.value in _TYPE_NAMES or _looks_like_type(tokens, pos):
+            try:
+                save = pos
+                node, pos = parse_var_decl(tokens, pos)
+                if node is None:
+                    pos = save
+                    node, pos = parse_expr_stmt(tokens, pos)
+            except ParseError:
+                pos = save
+                node, pos = parse_expr_stmt(tokens, pos)
+        else:
+            node, pos = parse_expr_stmt(tokens, pos)
+    else:
+        node, pos = parse_expr_stmt(tokens, pos)
+    
+    return node, pos
 
 
 def _parse_func_with_visibility(tokens: list[Token], pos: int, visibility: str | None, tok: Token):
@@ -451,8 +514,62 @@ def parse_class(tokens: list[Token], pos: int):
         raise ParseError('Expected class name', tokens[pos] if pos < len(tokens) else None)
     name = tokens[pos].value
     pos += 1
+    base = None
+    if pos < len(tokens) and tokens[pos].type == TokenType.LPAREN:
+        pos += 1
+        if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+            raise ParseError('Expected base class name', tokens[pos] if pos < len(tokens) else None)
+        base = tokens[pos].value
+        pos += 1
+        if pos >= len(tokens) or tokens[pos].type != TokenType.RPAREN:
+            raise ParseError('Expected ")" after base class name', tokens[pos] if pos < len(tokens) else None)
+        pos += 1
     body, pos = parse_suite(tokens, pos)
-    return {'type': 'class', 'name': name, 'body': body, '_token': tok}, pos
+    return {'type': 'class', 'name': name, 'base': base, 'body': body, '_token': tok}, pos
+
+
+def parse_try(tokens: list[Token], pos: int):
+    tok = tokens[pos]
+    pos += 1
+    body, pos = parse_suite(tokens, pos)
+    handlers = []
+    while pos < len(tokens):
+        while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+            pos += 1
+        if pos < len(tokens) and tokens[pos].type == TokenType.KEYWORD and tokens[pos].value == 'except':
+            etok = tokens[pos]
+            pos += 1
+            type_name = None
+            if pos < len(tokens) and tokens[pos].type == TokenType.IDENTIFIER:
+                type_name = tokens[pos].value
+                pos += 1
+            if pos >= len(tokens) or tokens[pos].type != TokenType.COLON:
+                raise ParseError('Expected ":" after except', tokens[pos] if pos < len(tokens) else None)
+            ebody, pos = parse_suite(tokens, pos)
+            handlers.append(ExceptHandler(type_name, ebody, token=etok))
+        else:
+            break
+    if not handlers:
+        raise ParseError('Expected at least one except clause', tok)
+    return Try(body, handlers, token=tok), pos
+
+
+def parse_raise(tokens: list[Token], pos: int):
+    tok = tokens[pos]
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+        raise ParseError('Expected exception class name after raise', tokens[pos] if pos < len(tokens) else None)
+    exc_type = tokens[pos].value
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.LPAREN:
+        raise ParseError('Expected "(" after exception class name', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+    message, pos = parse_expression(tokens, pos)
+    if pos >= len(tokens) or tokens[pos].type != TokenType.RPAREN:
+        raise ParseError('Expected ")" after message', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+    _expect_newline(tokens, pos, tok)
+    return Raise(exc_type, message, token=tok), pos
 
 
 def parse_struct_def(tokens: list[Token], pos: int):
@@ -550,7 +667,6 @@ def parse_import(tokens: list[Token], pos: int):
             pos += 1
         module = '@' + '/'.join(parts)
         node = Import(module, token=tok)
-        node.is_package = True
         return node, pos
     elif t.type == TokenType.IDENTIFIER:
         module = t.value
@@ -687,7 +803,7 @@ class VarDecl:
         return f'VarDecl({self.name}: {self.var_type} = {self.init})'
 
 class Import:
-    __slots__ = ('module', 'symbols', 'src_file', '_token', 'sub_ast', 'frameworks', 'constants', 'sdk_path', 'var_names', 'is_package')
+    __slots__ = ('module', 'symbols', 'src_file', '_token', 'sub_ast', 'frameworks', 'constants', 'sdk_path', 'var_names', 'is_package', 'prebuilt_ll_files')
     def __init__(self, module: str, symbols=None, token=None):
         self.module = module
         self.symbols = symbols or []
@@ -699,10 +815,41 @@ class Import:
         self.sdk_path = None
         self.var_names = set()
         self.is_package = False
+        self.prebuilt_ll_files = None
+
     def __repr__(self):
         return f'Import({self.module})'
 
 
+class ExceptHandler:
+    __slots__ = ('type_name', 'body', '_token')
+    def __init__(self, type_name: str | None, body: list, token=None):
+        self.type_name = type_name
+        self.body = body
+        self._token = token
+    def __repr__(self):
+        return f'ExceptHandler({self.type_name})'
+
+
+class Try:
+    __slots__ = ('body', 'handlers', '_token')
+    def __init__(self, body: list, handlers: list[ExceptHandler], token=None):
+        self.body = body
+        self.handlers = handlers
+        self._token = token
+    def __repr__(self):
+        return f'Try({self.body}, handlers={self.handlers})'
+
+
+class Raise:
+    __slots__ = ('exc_type', 'message', '_token')
+    def __init__(self, exc_type: str, message, token=None):
+        self.exc_type = exc_type
+        self.message = message
+        self._token = token
+    def __repr__(self):
+        return f'Raise({self.exc_type}, {self.message})'
+
 class NewExpr:
     __slots__ = ('type_expr', 'size', '_token')
     def __init__(self, type_expr, size=None, token=None):
@@ -761,6 +908,93 @@ class Field:
         return f'Field({self.name}: {self.type_expr})'
 
 
+class InlineAsm:
+    __slots__ = ('template', 'outputs', 'inputs', 'clobbers', 'volatile', '_token')
+    def __init__(self, template: str, outputs=None, inputs=None, clobbers=None, volatile=False, token=None):
+        self.template = template
+        self.outputs = outputs or []
+        self.inputs = inputs or []
+        self.clobbers = clobbers or []
+        self.volatile = volatile
+        self._token = token
+    def __repr__(self):
+        return f'InlineAsm({self.template}, volatile={self.volatile})'
+
+
+def parse_inline_asm(tokens: list[Token], pos: int):
+    tok = tokens[pos]
+    pos += 1
+    volatile = False
+    if pos < len(tokens) and tokens[pos].type == TokenType.IDENTIFIER and tokens[pos].value == 'volatile':
+        volatile = True
+        pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.LPAREN:
+        raise ParseError('Expected "(" after asm', tokens[pos] if pos < len(tokens) else tok)
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.STRING:
+        raise ParseError('Expected asm template string', tokens[pos] if pos < len(tokens) else tok)
+    template = tokens[pos].value
+    pos += 1
+    outputs = []
+    inputs = []
+    clobbers = []
+    if pos < len(tokens) and tokens[pos].type == TokenType.COLON:
+        pos += 1
+        if pos < len(tokens) and tokens[pos].type not in (TokenType.COLON, TokenType.RPAREN):
+            while True:
+                if pos >= len(tokens) or tokens[pos].type != TokenType.STRING:
+                    raise ParseError('Expected constraint string', tokens[pos] if pos < len(tokens) else tok)
+                constraint = tokens[pos].value
+                pos += 1
+                if pos >= len(tokens) or tokens[pos].type != TokenType.LPAREN:
+                    raise ParseError('Expected "(" after constraint', tokens[pos] if pos < len(tokens) else tok)
+                pos += 1
+                var_expr, pos = parse_expression(tokens, pos)
+                if pos >= len(tokens) or tokens[pos].type != TokenType.RPAREN:
+                    raise ParseError('Expected ")"', tokens[pos] if pos < len(tokens) else tok)
+                pos += 1
+                outputs.append((constraint, var_expr))
+                if pos < len(tokens) and tokens[pos].type == TokenType.COMMA:
+                    pos += 1
+                else:
+                    break
+        if pos < len(tokens) and tokens[pos].type == TokenType.COLON:
+            pos += 1
+            if pos < len(tokens) and tokens[pos].type not in (TokenType.COLON, TokenType.RPAREN):
+                while True:
+                    if pos >= len(tokens) or tokens[pos].type != TokenType.STRING:
+                        raise ParseError('Expected constraint string', tokens[pos] if pos < len(tokens) else tok)
+                    constraint = tokens[pos].value
+                    pos += 1
+                    if pos >= len(tokens) or tokens[pos].type != TokenType.LPAREN:
+                        raise ParseError('Expected "(" after constraint', tokens[pos] if pos < len(tokens) else tok)
+                    pos += 1
+                    arg_expr, pos = parse_expression(tokens, pos)
+                    if pos >= len(tokens) or tokens[pos].type != TokenType.RPAREN:
+                        raise ParseError('Expected ")"', tokens[pos] if pos < len(tokens) else tok)
+                    pos += 1
+                    inputs.append((constraint, arg_expr))
+                    if pos < len(tokens) and tokens[pos].type == TokenType.COMMA:
+                        pos += 1
+                    else:
+                        break
+        if pos < len(tokens) and tokens[pos].type == TokenType.COLON:
+            pos += 1
+            while True:
+                if pos >= len(tokens) or tokens[pos].type != TokenType.STRING:
+                    raise ParseError('Expected clobber string', tokens[pos] if pos < len(tokens) else tok)
+                clobbers.append(tokens[pos].value)
+                pos += 1
+                if pos < len(tokens) and tokens[pos].type == TokenType.COMMA:
+                    pos += 1
+                else:
+                    break
+    if pos >= len(tokens) or tokens[pos].type != TokenType.RPAREN:
+        raise ParseError('Expected ")" after asm', tokens[pos] if pos < len(tokens) else tok)
+    pos += 1
+    return InlineAsm(template, outputs, inputs, clobbers, volatile=volatile, token=tok), pos
+
+
 def parse_block(tokens: list[Token], pos: int = 0):
     stmts = []
     while pos < len(tokens) and tokens[pos].type not in (TokenType.DEDENT, TokenType.EOF):
@@ -928,6 +1162,15 @@ def parse_statement(tokens: list[Token], pos: int):
         handler = {'while': parse_while, 'for': parse_for, 'class': parse_class, 'struct': parse_struct_def, 'import': parse_import}[tok.value]
         return handler(tokens, pos)
 
+    if tok.type == TokenType.KEYWORD and tok.value == 'try':
+        return parse_try(tokens, pos)
+
+    if tok.type == TokenType.KEYWORD and tok.value == 'raise':
+        return parse_raise(tokens, pos)
+
+    if tok.type == TokenType.KEYWORD and tok.value == 'asm':
+        return parse_inline_asm(tokens, pos)
+
     if tok.type == TokenType.IDENTIFIER:
         if tok.value in _TYPE_NAMES or _looks_like_type(tokens, pos):
             try: