Typhon-Language 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

Typhon/SourceMap/defined_name_retrieve.py

@@ -0,0 +1,145 @@
+import ast
+
+from ..Driver.debugging import debug_verbose_print
+from ..Grammar.typhon_ast import (
+    set_defined_name,
+    get_pos_attributes,
+    set_import_from_names,
+)
+
+
+# Assume the base source code is in canonical form by ast.unparse
+class _DefinedNameRetriever(ast.NodeVisitor):
+    def __init__(self, unparsed_source_code: str):
+        self.unparsed_source_code = unparsed_source_code
+
+    def _visit_defines(
+        self,
+        node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef,
+        column_offset: int,
+    ):
+        pos = get_pos_attributes(node)
+        start_line = pos["lineno"]  # decorator is not included in the original position
+        start_col = pos["col_offset"] + column_offset
+        debug_verbose_print(
+            f'Retrieving defined name "{node.name}" for node: {ast.dump(node)} at line {start_line}, col {start_col}'
+        )
+        name = ast.Name(
+            id=node.name,
+            ctx=ast.Store(),
+            lineno=start_line,
+            col_offset=start_col,
+            end_lineno=start_line,
+            end_col_offset=start_col + len(node.name),
+        )
+        set_defined_name(node, name)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        self._visit_defines(node, len("def "))
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        self._visit_defines(node, len("async def "))
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef):
+        self._visit_defines(node, len("class "))
+        self.generic_visit(node)
+
+    def visit_alias(self, node: ast.alias):
+        pos = get_pos_attributes(node)
+        start_line = pos["lineno"]
+        start_col = pos["col_offset"]
+        if node.asname:
+            if pos["end_col_offset"]:
+                start_col = pos["end_col_offset"] - len(node.asname)
+            else:
+                # Fallback: search 'as' in the source code line
+                # TODO: Is this truly necessary? and reliable?
+                line_start = self.unparsed_source_code.splitlines()[start_line - 1]
+                as_index = line_start.find(" as ", start_col)
+                if as_index != -1:
+                    start_col = as_index + len(" as ")
+            name = ast.Name(
+                id=node.asname,
+                ctx=ast.Store(),
+                lineno=start_line,
+                col_offset=start_col,
+                end_lineno=start_line,
+                end_col_offset=start_col + len(node.asname),
+            )
+            set_defined_name(node, name)
+        else:
+            # No asname. Stem of imported name is the defined name.
+            after_last_dot_index = node.name.rfind(".") + 1
+            start_col += after_last_dot_index
+            defined_name = node.name[after_last_dot_index:]
+            name = ast.Name(
+                id=defined_name,
+                ctx=ast.Store(),
+                lineno=start_line,
+                col_offset=start_col,
+                end_lineno=start_line,
+                end_col_offset=start_col + len(defined_name),
+            )
+            set_defined_name(node, name)
+
+    def visit_Attribute(self, node: ast.Attribute):
+        pos = get_pos_attributes(node)
+        start_line = pos["lineno"]
+        end_col = pos["end_col_offset"]
+        # The defined name is the attribute name.
+        attr_index = (
+            end_col - len(node.attr) - 1 if end_col is not None else pos["col_offset"]
+        )
+        debug_verbose_print(
+            f'Retrieving defined name for attribute "{node.attr}" of {ast.dump(node.value)} at line {start_line}, col {attr_index}'
+        )
+        name = ast.Name(
+            id=node.attr,
+            ctx=node.ctx,
+            lineno=start_line,
+            col_offset=attr_index,
+            end_lineno=start_line,
+            end_col_offset=end_col,
+        )
+        set_defined_name(node, name)
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        for alias in node.names:
+            self.visit(alias)
+        column = node.col_offset + len("from ") + node.level * len(".")
+        module_names: list[ast.Name] = []
+        for mod in node.module.split(".") if node.module else []:
+            if mod:
+                name = ast.Name(
+                    id=mod,
+                    lineno=node.lineno,
+                    col_offset=column,
+                    end_lineno=node.lineno,
+                    end_col_offset=column + len(mod),
+                    ctx=ast.Load(),
+                )
+                module_names.append(name)
+            column += len(mod) + len(".")
+        set_import_from_names(node, module_names)
+
+    def visit_arg(self, node: ast.arg):
+        pos = get_pos_attributes(node)
+        start_col = pos["col_offset"]
+        name = ast.Name(
+            id=node.arg,
+            ctx=ast.Store(),
+            lineno=pos["lineno"],
+            col_offset=start_col,
+            end_lineno=pos["end_lineno"],
+            end_col_offset=start_col + len(node.arg),
+        )
+        set_defined_name(node, name)
+        self.generic_visit(node)
+
+
+def defined_name_retrieve(node: ast.AST, unparsed_source_code: str) -> None:
+    visitor = _DefinedNameRetriever(unparsed_source_code)
+    visitor.visit(node)

Typhon/Transform/comprehension_to_function.py

@@ -56,12 +56,9 @@ class _Transform(TyphonASTTransformer):
         return result
 
     def visit_ControlComprehension(self, node: ControlComprehension):
+        clear_is_control_comprehension(node)
         return ast.Call(
-            func=ast.Name(
-                id=node.id,
-                ctx=ast.Load(),
-                **get_pos_attributes(node),
-            ),
+            func=node,
             args=[],
             keywords=[],
             **get_pos_attributes(node),

Typhon/Transform/const_member_to_final.py

@@ -4,9 +4,8 @@ from ..Grammar.typhon_ast import (
     get_pos_attributes,
     is_let_assign,
 )
-from .visitor import TyphonASTTransformer, flat_append
-from .name_generator import get_final_name
-from .utils import add_import_for_final
+from .visitor import TyphonASTTransformer
+from .utils.imports import add_import_for_final, get_final
 
 
 class ConstMemberToFinal(TyphonASTTransformer):
@@ -24,7 +23,9 @@ class ConstMemberToFinal(TyphonASTTransformer):
         target: ast.Name,
         annotation: ast.expr | None,
     ):
-        assert is_decl_assign(node), "Unexpected non-decl assign in class def"
+        assert is_decl_assign(node), (
+            f"Unexpected non-decl assign in class def: {ast.dump(node)}"
+        )
         if not is_let_assign(node):
             return self.generic_visit(node)
         self.changed = True
@@ -32,15 +33,17 @@ class ConstMemberToFinal(TyphonASTTransformer):
         self.generic_visit(node)
         if annotation is not None:
             new_annotation = ast.Subscript(
-                value=ast.Name(id=get_final_name(), ctx=ast.Load(), **pos),
+                value=get_final(ctx=ast.Load(), **pos),
                 slice=annotation,
                 ctx=ast.Load(),
                 **pos,
             )
         else:
-            new_annotation = ast.Name(id=get_final_name(), ctx=ast.Load(), **pos)
+            new_annotation = get_final(ctx=ast.Load(), **pos)
         return ast.AnnAssign(
-            target=ast.Name(id=target.id, ctx=ast.Store(), **pos),
+            target=ast.Name(
+                id=target.id, ctx=ast.Store(), **get_pos_attributes(target)
+            ),
             annotation=new_annotation,
             value=node.value,
             simple=1,
@@ -73,4 +76,6 @@ def const_member_to_final(module: ast.Module):
     transformer = ConstMemberToFinal(module)
     transformer.run()
     if transformer.changed:
+        # If we use add_import_get_final, final import confuses the visitor
+        # by pushing the current visiting node.
         add_import_for_final(module)

Typhon/Transform/extended_patterns.py

@@ -0,0 +1,139 @@
+import ast
+from dataclasses import dataclass
+from typing import Protocol, Iterable, Final
+from ..Grammar.typhon_ast import (
+    RecordLiteral,
+    get_record_literal_fields,
+    get_record_type_fields,
+    get_pos_attributes,
+    pos_attribute_to_range,
+    get_empty_pos_attributes,
+    PosAttributes,
+    set_is_var,
+    is_record_literal,
+    is_record_type,
+    is_attributes_pattern,
+    is_pattern_tuple,
+)
+from .visitor import TyphonASTVisitor, TyphonASTTransformer, flat_append
+from .utils.imports import (
+    get_insert_point_for_class,
+)
+from .utils.make_class import (
+    make_protocol_definition,
+)
+
+
+@dataclass
+class AttributePatternFieldInfo:
+    name: ast.Name
+    annotation: ast.expr
+
+
+@dataclass
+class AttributePatternInfo:
+    class_name: str
+    pattern: ast.MatchClass
+    record: ast.Name
+    type_variables: list[str]
+    fields: list[AttributePatternFieldInfo]
+
+
+class _GatherRecords(TyphonASTVisitor):
+    record_patterns: list[AttributePatternInfo]
+
+    def __init__(self, module: ast.Module):
+        super().__init__(module)
+        self.record_patterns = []
+
+    def visit_MatchClass(self, node: ast.MatchClass):
+        if isinstance(node.cls, ast.Name) and is_attributes_pattern(node.cls):
+            record_cls = node.cls
+            type_vars: list[str] = []
+            fields: list[AttributePatternFieldInfo] = []
+            # Gather the member names from keyword patterns.
+            for kwd_name in node.kwd_attrs:
+                type_var = self.new_typevar_name(kwd_name)
+                type_vars.append(type_var)
+                fields.append(
+                    AttributePatternFieldInfo(
+                        name=ast.Name(
+                            id=kwd_name,
+                            ctx=ast.Load(),
+                            **get_pos_attributes(node.cls),
+                        ),
+                        annotation=ast.Name(
+                            id=type_var, ctx=ast.Load(), **get_pos_attributes(node.cls)
+                        ),
+                    )
+                )
+            self.record_patterns.append(
+                AttributePatternInfo(
+                    self.new_class_name(""),
+                    node,
+                    record_cls,
+                    type_vars,
+                    fields,
+                )
+            )
+        return self.generic_visit(node)
+
+
+class _Transform(TyphonASTTransformer):
+    def __init__(
+        self,
+        module: ast.Module,
+        class_for_record_pattern: dict[ast.Name, ast.ClassDef],
+        info_for_record_pattern: dict[ast.Name, AttributePatternInfo],
+    ):
+        super().__init__(module)
+        self.class_for_record_pattern = class_for_record_pattern
+        self.info_for_record_pattern = info_for_record_pattern
+
+    def visit_Name(self, node: ast.Name):
+        if node in self.class_for_record_pattern:
+            class_def = self.class_for_record_pattern[node]
+            info = self.info_for_record_pattern[node]
+            return ast.Name(
+                id=class_def.name, ctx=ast.Load(), **get_pos_attributes(node)
+            )
+        return self.generic_visit(node)
+
+    # Convert tuple pattern
+    def visit_MatchSequence(self, node: ast.MatchSequence):
+        if is_pattern_tuple(node):
+            pos = get_pos_attributes(node)
+            return ast.MatchClass(
+                cls=ast.Name(id="tuple", ctx=ast.Load(), **pos),
+                patterns=[
+                    ast.MatchSequence(node.patterns, **pos_attribute_to_range(pos))
+                ],
+                kwd_attrs=[],
+                kwd_patterns=[],
+                **pos_attribute_to_range(pos),
+            )
+        return self.generic_visit(node)
+
+
+def extended_protocol(module: ast.Module):
+    gatherer = _GatherRecords(module)
+    gatherer.run()
+    # Create class and information for each record pattern.
+    class_for_record_pattern: dict[ast.Name, ast.ClassDef] = {}
+    info_for_record_pattern: dict[ast.Name, AttributePatternInfo] = {}
+    for info in gatherer.record_patterns:
+        class_def_type = make_protocol_definition(
+            module,
+            info.class_name,
+            info.type_variables,
+            info.fields,
+            get_pos_attributes(info.record),
+        )
+        class_for_record_pattern[info.record] = class_def_type
+        info_for_record_pattern[info.record] = info
+        module.body.insert(get_insert_point_for_class(module), class_def_type)
+    _Transform(
+        module,
+        class_for_record_pattern,
+        info_for_record_pattern,
+    ).run()

Typhon/Transform/forbidden_statements.py

@@ -8,6 +8,8 @@ from ..Grammar.typhon_ast import (
     is_decl_assign,
     is_multi_decl,
     PosAttributes,
+    is_let_else,
+    is_inline_with,
 )
 from ..Grammar.syntax_errors import (
     raise_forbidden_statement_error,
@@ -48,6 +50,28 @@ class ForbiddenStatementChecker(TyphonASTVisitor):
                 )
         return self.generic_visit(node)
 
+    def visit_With_AsyncWith(self, node: ast.With | ast.AsyncWith):
+        if is_inline_with(node) and self.now_is_top_level():
+            self._raise_forbidden_statement(
+                "Inline `with` statement in module top level is forbidden",
+                get_pos_attributes(node),
+            )
+        return self.generic_visit(node)
+
+    def visit_With(self, node: ast.With):
+        self.visit_With_AsyncWith(node)
+
+    def visit_AsyncWith(self, node: ast.AsyncWith):
+        self.visit_With_AsyncWith(node)
+
+    def visit_If(self, node: ast.If):
+        if is_let_else(node) and self.now_is_top_level() and node.orelse:
+            self._raise_forbidden_statement(
+                "`let-else` statement in module top level is forbidden",
+                get_pos_attributes(node),
+            )
+        return self.generic_visit(node)
+
     # TODO: Check control statements inside class definition.
 
     def _is_valid_stmt_in_class(self, node: ast.stmt) -> bool:
@@ -61,6 +85,7 @@ class ForbiddenStatementChecker(TyphonASTVisitor):
                     ast.Import,
                     ast.AnnAssign,
                     ast.Assign,
+                    ast.Pass,
                 ),
             )
         ):

Typhon/Transform/if_while_let.py

@@ -5,11 +5,13 @@ from ..Grammar.typhon_ast import (
     is_let_else,
     set_is_var,
     set_is_let_else,
+    LetPatternInfo,
 )
 from .visitor import TyphonASTTransformer, flat_append
 from contextlib import contextmanager
 from dataclasses import dataclass
-from .utils import is_body_jump_away
+from .utils.jump_away import is_body_jump_away
+from ..Grammar.syntax_errors import raise_let_missing_else_error
 
 
 class IfMultipleLetTransformer(TyphonASTTransformer):
@@ -32,6 +34,13 @@ class IfMultipleLetTransformer(TyphonASTTransformer):
                                 match <subjectN>:
                                     case <patternN> if <cond>:
                                         <body>
+                                    case _:
+                                        pass
+                            ...
+                        case _:
+                            pass
+                case _:
+                    pass
         else:
             <orelse>
 
@@ -43,6 +52,11 @@ class IfMultipleLetTransformer(TyphonASTTransformer):
                             match <subjectN>:
                                 case <patternN> if <cond>:
                                     <body>
+                                case _:
+                                    pass
+                        ...
+            case _:
+                pass
         <orelse> # Unconditional execution of orelse
 
         when <body> does not jump away:
@@ -54,20 +68,22 @@ class IfMultipleLetTransformer(TyphonASTTransformer):
                                 case <patternN> if <cond>:
                                     <else_flag> = False
                                     <body>
+                                case _:
+                                    pass
+                        ...
+            case _:
+                pass
         if <else_flag>: # Only when body did not execute
             <orelse>
     """
 
-    def visit_If(self, node: ast.If):
-        self.generic_visit(node)
-        body = get_let_pattern_body(node)
-        if body is None:
-            return node
+    def visit_IfLet(self, node: ast.If, info: LetPatternInfo) -> list[ast.stmt]:
+        body = info.body
         pos = get_pos_attributes(node)
         # When jump away, does not need flag control.
         jump_away = is_body_jump_away(body)
         if jump_away:
-            result: list[ast.stmt] = node.body
+            result: list[ast.stmt] = node.body  # Inside if True
             if node.orelse:
                 result.extend(node.orelse)
             return result
@@ -101,6 +117,101 @@ class IfMultipleLetTransformer(TyphonASTTransformer):
             )
         return result
 
+    """
+        let <pattern1> = <subject1>, <pattern2> = <subject2>, ...,
+            <patternN> = <subjectN>
+        else { # else clause is required unless all patterns are irrefutable
+            <orelse> # If exists, must jump away.
+        }
+        <body>
+
+    --> (temporary represented now)
+
+        if True: # multiple_let_pattern_body set to <body>
+            match <subject1>:
+                case <pattern1>:
+                    match <subject2>:
+                        case <pattern2>:
+                            ...
+                                match <subjectN>:
+                                    case <patternN>:
+                                        <body>
+                                    case _:
+                                        pass
+                                        (raise TypeError) # If else does not exist
+                            ...
+                        case _:
+                            pass
+                            (raise TypeError) # If else does not exist
+                case _:
+                    pass
+                    (raise TypeError) # If else does not exist
+        else: # If exists
+            <orelse>
+
+    --> (transformation here)
+
+        The case when <body> does jumps away:
+
+        match <subject1>:
+            case <pattern1>:
+                ...
+                    match <subjectN>:
+                        case <patternN>:
+                            <body>
+                        case _:
+                            pass
+                            (raise TypeError) # If else does not exist
+                ...
+            case _:
+                pass
+        <orelse> # Unconditional execution of orelse
+
+        The case when <body> does not jump away:
+
+        <else_flag> = True
+        match <subject1>:
+            case <pattern1>:
+                ...
+                    match <subjectN>:
+                        case <patternN>:
+                            <else_flag> = False
+                            <body>
+                        case _:
+                            pass
+                            (raise TypeError) # If else does not exist
+                ...
+            case _:
+                pass
+                (raise TypeError) # If else does not exist
+        if <else_flag>: # Only when body did not execute
+            <orelse> # If exists
+    """
+
+    def visit_LetElse(self, node: ast.If, info: LetPatternInfo) -> list[ast.stmt]:
+        pos = get_pos_attributes(node)
+        orelse = node.orelse
+        if not orelse:
+            if info.is_all_pattern_irrefutable:
+                return node.body  # Simply return inside if True
+            else:
+                raise_let_missing_else_error(
+                    "let pattern is irrefutable, possibly fails to match. else clause of let-else statement is required.",
+                    **pos,
+                )
+        # With orelse, same as IfLet.
+        return self.visit_IfLet(node, info)
+
+    def visit_If(self, node: ast.If):
+        self.generic_visit(node)  # Visit children first
+        info = get_let_pattern_body(node)
+        if info is None:  # Not a if-let nor let-else
+            return node
+        if is_let_else(node):
+            return self.visit_LetElse(node, info)
+        else:
+            return self.visit_IfLet(node, info)
+
 
 class WhileLetTransformer(TyphonASTTransformer):
     """
@@ -149,8 +260,8 @@ class WhileLetTransformer(TyphonASTTransformer):
 
     def visit_While(self, node: ast.While):
         self.generic_visit(node)
-        body = get_let_pattern_body(node)
-        if body is None:
+        info = get_let_pattern_body(node)
+        if info is None:
             return node
         pos = get_pos_attributes(node)
         # <continue_flag> = True
@@ -161,14 +272,14 @@ class WhileLetTransformer(TyphonASTTransformer):
             **pos,
         )
         set_is_var(continue_flag_assign_true)
-        if not is_body_jump_away(body):
+        if not is_body_jump_away(info.body):
             # <continue_flag> = True at end of body
             continue_flag_set_true = ast.Assign(
                 targets=[ast.Name(id=continue_flag_name, ctx=ast.Store(), **pos)],
                 value=ast.Constant(value=True),
                 **pos,
             )
-            body.append(continue_flag_set_true)
+            info.body.append(continue_flag_set_true)
         # <continue_flag> = False at start of while body
         continue_flag_set_false = ast.Assign(
             targets=[ast.Name(id=continue_flag_name, ctx=ast.Store(), **pos)],

Typhon/Transform/inline_statement_block_capture.py

@@ -4,12 +4,13 @@ from ..Grammar.typhon_ast import (
     clear_inline_with,
     is_let_else,
     get_let_pattern_body,
+    get_pos_attributes,
 )
 from .visitor import TyphonASTVisitor, flat_append
 from contextlib import contextmanager
 from dataclasses import dataclass
 from ..Driver.debugging import debug_print, debug_verbose_print
-from .utils import is_body_jump_away
+from .utils.jump_away import is_body_jump_away
 
 
 @dataclass
@@ -73,14 +74,14 @@ class _InlineStatementBlockCaptureGather(TyphonASTVisitor):
 
         --> (is represented here actually)
 
-            if True: # multiple_let_pattern_body set to empty
+            if True:
                 match <subject1>:
                     case <pattern1>:
                         match <subject2>:
                             ...
                                 match <subjectN>:
                                     case <patternN>:
-                                        # empty
+                                        # empty # info.body
             else:
                 <orelse> # Must jump away.
             <after>
@@ -96,7 +97,7 @@ class _InlineStatementBlockCaptureGather(TyphonASTVisitor):
 
         --> (transformation here actually)
 
-            if True: # multiple_let_pattern_body set to empty
+            if True: # let_pattern_body set to empty
                 match <subject1>:
                     case <pattern1>:
                         match <subject2>:
@@ -107,8 +108,8 @@ class _InlineStatementBlockCaptureGather(TyphonASTVisitor):
             else:
                 <orelse> # Must jump away.
         """
-        body = get_let_pattern_body(node)
-        if body is None or not is_let_else(node):
+        info = get_let_pattern_body(node)
+        if info is None or not is_let_else(node):
             self._visit_list_scoped(node, node.body)
             self._visit_list_scoped(node, node.orelse)
             return
@@ -118,18 +119,23 @@ class _InlineStatementBlockCaptureGather(TyphonASTVisitor):
             node=node,
             parent_block=parent_block_node,
             parent_block_body=parent_block_body,
-            body_capture_into=body,
+            body_capture_into=info.body,
         )
         debug_print(
-            f"Found let else: \n    node:{ast.dump(node)} \n        parent:{ast.dump(parent_block_node)}\n            body:{list(map(ast.dump, body))}"
+            f"Found let else: \n    node:{ast.dump(node)} \n        parent:{ast.dump(parent_block_node)}\n            body:{list(map(ast.dump, info.body))}"
         )
-        if not is_body_jump_away(node.orelse):
-            raise RuntimeError(
-                "let-else's else body must jump away"
-            )  # TODO: Arrow NoReturn function call
+        if node.orelse:
+            if not is_body_jump_away(node.orelse):
+                raise RuntimeError(
+                    "let-else's else body must jump away"
+                )  # TODO: Arrow NoReturn function call
+        else:
+            # Empty else body. The pattern must be irrefutable.
+            # The error is checked in if_while_let_transform.
+            pass
         self._visit_list_scoped(node, node.orelse)
         # Hack to make parent of the followings to case's body
-        self.parent_block_scopes[-1] = (node, body)
+        self.parent_block_scopes[-1] = (node, info.body)
 
     def visit_For(self, node: ast.For):
         # No need to visit target, iter
@@ -215,9 +221,10 @@ def inline_statement_block_capture(module: ast.Module):
         if node not in parent_block_body:
             raise RuntimeError("Parent block not found")  # TODO: proper error handling
         index = parent_block_body.index(node)
-        # Move the remained stmts into with_node's body
-        body_capture_into.clear()
+        # Move the remained stmts into capturer's body
         body_capture_into.extend(parent_block_body[index + 1 :])
+        if not body_capture_into:
+            body_capture_into.append(ast.Pass(**get_pos_attributes(node)))
         # Remove the remained stmts from parent block
         del parent_block_body[index + 1 :]
         debug_verbose_print(