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

Typhon/Grammar/syntax_errors.py

@@ -116,6 +116,17 @@ def raise_type_annotation_error(
     raise TypeAnnotationError(message, **pos)
 
 
+class LetMissingElseError(TyphonSyntaxError):
+    pass
+
+
+def raise_let_missing_else_error(
+    message: str,
+    **pos: Unpack[PosAttributes],
+):
+    raise LetMissingElseError(message, **pos)
+
+
 def _get_range_of_error(
     syntax_error: SyntaxError | TyphonSyntaxError,
 ) -> Range:

Typhon/Grammar/typhon_ast.py

@@ -2,6 +2,7 @@
 
 import ast
 from typing import Union, Unpack, TypedDict, Tuple, cast
+from dataclasses import dataclass
 from copy import copy
 from ..Driver.debugging import debug_print, debug_verbose_print
 
@@ -77,6 +78,75 @@ def get_empty_pos_attributes() -> PosAttributes:
     )
 
 
+_ANONYMOUS_NAME = "_typh_anonymous"
+_anonymous_global_id = 0
+
+
+def set_anonymous_name_id(node: ast.Name, id: int) -> ast.Name:
+    setattr(node, _ANONYMOUS_NAME, id)
+    return node
+
+
+def get_anonymous_name_id(node: ast.Name) -> int | None:
+    return getattr(node, _ANONYMOUS_NAME, None)
+
+
+def clear_anonymous_name(node: ast.Name) -> None:
+    if hasattr(node, _ANONYMOUS_NAME):
+        delattr(node, _ANONYMOUS_NAME)
+
+
+def is_anonymous_name(node: ast.Name) -> bool:
+    return hasattr(node, _ANONYMOUS_NAME)
+
+
+def make_anonymous_name(
+    ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> tuple[ast.Name, int]:
+    global _anonymous_global_id
+    anon_id = _anonymous_global_id
+    name = ast.Name(f"{_ANONYMOUS_NAME}_{anon_id}", ctx, **kwargs)
+    set_anonymous_name_id(name, anon_id)
+    _anonymous_global_id += 1
+    return name, anon_id
+
+
+def copy_anonymous_name(src: ast.Name, ctx: ast.expr_context) -> ast.Name:
+    result = ast.Name(src.id, ctx, **get_pos_attributes(src))
+    anon_id = get_anonymous_name_id(src)
+    if anon_id is not None:
+        set_anonymous_name_id(result, anon_id)
+    return result
+
+
+_TYPE_IGNORE_NODES = "_typh_type_ignore"
+
+
+def get_type_ignore_tag(node: ast.AST) -> str | None:
+    return getattr(node, _TYPE_IGNORE_NODES, None)
+
+
+def get_type_ignore_comment(node: ast.AST) -> str | None:
+    tag = get_type_ignore_tag(node)
+    if tag is not None:
+        return f"# type: ignore[{tag}]"
+    return None
+
+
+def set_type_ignore_node(node: ast.AST, tag: str) -> ast.AST:
+    setattr(node, _TYPE_IGNORE_NODES, tag)
+    return node
+
+
+def is_type_ignore_node(node: ast.AST) -> bool:
+    return hasattr(node, _TYPE_IGNORE_NODES)
+
+
+def clear_type_ignore_node(node: ast.AST) -> None:
+    if hasattr(node, _TYPE_IGNORE_NODES):
+        delattr(node, _TYPE_IGNORE_NODES)
+
+
 # Normal assignments, let assignments for variable declarations,
 # and constant assignments for constant definitions.
 # They all are Assign/AnnAssign in Python, we distinguish them by
@@ -93,7 +163,13 @@ def is_decl_stmt(node: ast.AST) -> bool:
 
 
 type DeclarableStmt = Union[
-    ast.Assign, ast.AnnAssign, ast.withitem, ast.For, ast.AsyncFor, ast.comprehension
+    ast.Assign,
+    ast.AnnAssign,
+    ast.withitem,
+    ast.For,
+    ast.AsyncFor,
+    ast.comprehension,
+    ast.pattern,
 ]
 
 _IS_VAR = "_typh_is_var"
@@ -399,6 +475,99 @@ def declaration_as_withitem(assign: Union[ast.Assign, ast.AnnAssign]) -> ast.wit
         return item
 
 
+def _make_with_let_pattern(
+    is_async: bool,
+    decl_type: str,
+    pattern_subjects: list[tuple[ast.pattern, ast.expr]],
+    body: list[ast.stmt],
+    **kwargs: Unpack[PosAttributes],
+) -> tuple[ast.stmt, list[ast.withitem]]:
+    items: list[ast.withitem] = []
+    pattern_vars: list[tuple[ast.pattern, ast.expr]] = []
+    for pattern, subject in pattern_subjects:
+        var, var_id = make_anonymous_name(ast.Store(), **get_pos_attributes(pattern))
+        item = ast.withitem(context_expr=subject, optional_vars=var)
+        _set_is_let_var(item, decl_type)
+        items.append(item)
+        pattern_vars.append((pattern, copy_anonymous_name(var, ast.Load())))
+    let_pattern_stmt = make_if_let(
+        decl_type,
+        pattern_subjects=pattern_vars,
+        cond=None,
+        body=body,
+        orelse=None,
+        is_let_else=True,
+        **kwargs,
+    )
+    return let_pattern_stmt, items
+
+
+def make_with_let_pattern(
+    is_async: bool,
+    decl_type: str,
+    pattern_subjects: list[tuple[ast.pattern, ast.expr]],
+    body: list[ast.stmt],
+    **kwargs: Unpack[PosAttributes],
+) -> ast.With | ast.AsyncWith:
+    let_pattern_stmt, items = _make_with_let_pattern(
+        is_async,
+        decl_type,
+        pattern_subjects,
+        body,
+        **kwargs,
+    )
+    return make_with_stmt(
+        is_async=is_async,
+        items=items,
+        body=[let_pattern_stmt],
+        is_inline=False,
+        **kwargs,
+    )
+
+
+def make_inline_with_let_pattern(
+    is_async: bool,
+    decl_type: str,
+    pattern_subjects: list[tuple[ast.pattern, ast.expr]],
+    **kwargs: Unpack[PosAttributes],
+) -> list[ast.stmt]:
+    """
+    with <expr1> as <temp_name1>, ...: # inline with_let_pattern
+    if True: # Sequentially expanded. Captured later.
+        match <temp_name1>:
+            case <pattern1>:
+                match <temp_name2>:
+                    case <pattern2>:
+                        ...
+                            match <temp_nameN>:
+                                case <patternN> if <cond>:
+                                    <body>
+                                case _:
+                                    pass
+                        ...
+                    case _:
+                        pass
+            case _:
+                pass
+    """
+    let_pattern_stmt, items = _make_with_let_pattern(
+        is_async,
+        decl_type,
+        pattern_subjects,
+        body=[],
+        **kwargs,
+    )
+    inline_with = make_with_stmt(
+        is_async=is_async,
+        items=items,
+        body=[],
+        is_inline=True,
+        **kwargs,
+    )
+    # inline_with will capture the let pattern stmt (and the following stmts) in its body later.
+    return [inline_with, let_pattern_stmt]
+
+
 # Use Name as a function literal. Replaced to name of FunctionDef.
 type FunctionLiteral = ast.Name
 
@@ -628,6 +797,40 @@ def make_for_stmt(
         return result
 
 
+def make_for_let_pattern(
+    decl_type: str,
+    pattern: ast.pattern,
+    iter: ast.expr,
+    body: list[ast.stmt],
+    orelse: list[ast.stmt] | None,
+    type_comment: str | None,
+    is_async: bool,
+    **kwargs: Unpack[PosAttributes],
+):
+    temp_name, anon_id = make_anonymous_name(ast.Load(), **get_pos_attributes(pattern))
+    let_stmt = make_if_let(
+        decl_type,
+        pattern_subjects=[(pattern, temp_name)],
+        cond=None,
+        body=body,
+        orelse=None,
+        is_let_else=True,
+        **kwargs,
+    )
+    temp_name_store = copy_anonymous_name(temp_name, ast.Store())
+    return make_for_stmt(
+        decl_type=decl_type,
+        target=temp_name_store,
+        type_annotation=None,
+        iter=iter,
+        body=[let_stmt],
+        orelse=orelse,
+        type_comment=type_comment,
+        is_async=is_async,
+        **kwargs,
+    )
+
+
 def _make_none_check(name: str, pos: PosAttributes) -> ast.Compare:
     return ast.Compare(
         left=ast.Name(id=name, ctx=ast.Load(), **pos),
@@ -641,12 +844,18 @@ _LET_PATTERN_BODY = "_typh_multiple_let_pattern_body"
 _IS_LET_ELSE = "_typh_is_let_else"
 
 
-def get_let_pattern_body(node: ast.While | ast.If) -> list[ast.stmt] | None:
+@dataclass
+class LetPatternInfo:
+    body: list[ast.stmt]
+    is_all_pattern_irrefutable: bool
+
+
+def get_let_pattern_body(node: ast.While | ast.If) -> LetPatternInfo | None:
     return getattr(node, _LET_PATTERN_BODY, None)
 
 
 def set_let_pattern_body(
-    node: ast.While | ast.If, body: list[ast.stmt]
+    node: ast.While | ast.If, body: LetPatternInfo
 ) -> ast.While | ast.If:
     setattr(node, _LET_PATTERN_BODY, body)
     return node
@@ -657,21 +866,25 @@ def clear_let_pattern_body(node: ast.While | ast.If) -> None:
         delattr(node, _LET_PATTERN_BODY)
 
 
-def is_let_else(node: ast.If | ast.Match) -> bool:
+type LetElseAnnotatedNode = ast.If | ast.Match | ast.match_case
+
+
+def is_let_else(node: LetElseAnnotatedNode) -> bool:
     return getattr(node, _IS_LET_ELSE, False)
 
 
-def set_is_let_else(node: ast.If | ast.Match, is_let_else: bool) -> ast.stmt:
+def set_is_let_else[T: LetElseAnnotatedNode](node: T, is_let_else: bool) -> T:
     setattr(node, _IS_LET_ELSE, is_let_else)
     return node
 
 
-def clear_is_let_else(node: ast.If | ast.Match) -> None:
+def clear_is_let_else(node: LetElseAnnotatedNode) -> None:
     if hasattr(node, _IS_LET_ELSE):
         delattr(node, _IS_LET_ELSE)
 
 
 def make_if_let(
+    decl_type: str,
     pattern_subjects: list[tuple[ast.pattern, ast.expr]],
     cond: ast.expr | None,
     body: list[ast.stmt],
@@ -681,25 +894,24 @@ def make_if_let(
 ) -> ast.stmt:
     if len(pattern_subjects) == 0:
         raise SyntaxError("if let must have at least one pattern")
-    # elif len(pattern_subjects) == 1:
-    #     (pattern, subject) = pattern_subjects[0]
-    #     return set_is_let_else(
-    #         _make_if_let_single(subject, pattern, cond, body, orelse, **kwargs),
-    #         is_let_else,
-    #     )
     else:
         return set_is_let_else(
-            _make_if_let_multiple(pattern_subjects, cond, body, orelse, **kwargs),
+            _make_if_let_multiple(
+                decl_type, pattern_subjects, cond, body, orelse, is_let_else, **kwargs
+            ),
             is_let_else,
         )
 
 
 def _make_if_let_single_case(
+    decl_type: str,
     pattern: ast.pattern,
     cond: ast.expr | None,
     body: list[ast.stmt],
     make_none_check: bool,
+    is_let_else: bool,
 ) -> ast.match_case:
+    _set_is_let_var(pattern, decl_type)
     if (
         isinstance(pattern, ast.MatchAs)
         and pattern.pattern is None
@@ -709,37 +921,66 @@ def _make_if_let_single_case(
     ):
         # Variable capture pattern, e.g. `let x = ...` without condition.
         # In this case, the condition is None check.
-        return ast.match_case(
-            pattern=pattern,
-            guard=_make_none_check(pattern.name, get_pos_attributes(pattern)),
-            body=body,
+        return set_is_let_else(
+            ast.match_case(
+                pattern=pattern,
+                guard=_make_none_check(pattern.name, get_pos_attributes(pattern)),
+                body=body,
+            ),
+            is_let_else,
         )
     else:
-        return ast.match_case(
-            pattern=pattern,
-            guard=cond,
-            body=body,
+        return set_is_let_else(
+            ast.match_case(
+                pattern=pattern,
+                guard=cond,
+                body=body,
+            ),
+            is_let_else,
         )
 
 
 def _make_nested_match_for_multiple_let(
+    decl_type: str,
     pattern_subjects: list[tuple[ast.pattern, ast.expr]],
     cond: ast.expr | None,
     body: list[ast.stmt],
+    type_error_on_failure: bool,
+    is_let_else: bool,
     **kwargs: Unpack[PosAttributes],
 ) -> list[ast.stmt]:
     # Build nested match statements from inside out.
     for pattern, subject in reversed(pattern_subjects):
+        # Add a wildcard case to handle non-matching case to avoid linter error.
+        default_case = ast.match_case(  # case _: pass
+            pattern=ast.MatchAs(
+                name=None, pattern=None, **pos_attribute_to_range(kwargs)
+            ),
+            guard=None,
+            body=[
+                ast.Raise(
+                    ast.Name(id="TypeError", ctx=ast.Load(), **kwargs),
+                    None,
+                    **kwargs,
+                )
+                if type_error_on_failure
+                else ast.Pass(**kwargs)
+            ],
+        )
+        if type_error_on_failure:
+            # Ignore unreachable clause error for this default case, because this is recovery for the
+            # case type check can not detect a pattern mismatch (e.g. due to cast).
+            set_type_ignore_node(default_case, "all")
         cases = [
-            _make_if_let_single_case(pattern, cond, body, make_none_check=cond is None),
-            # Add a wildcard case to handle non-matching case to avoid linter error.
-            ast.match_case(  # case _: pass
-                pattern=ast.MatchAs(
-                    name=None, pattern=None, **pos_attribute_to_range(kwargs)
-                ),
-                guard=None,
-                body=[ast.Pass(**kwargs)],
+            _make_if_let_single_case(
+                decl_type,
+                pattern,
+                cond,
+                body,
+                make_none_check=cond is None,
+                is_let_else=is_let_else,
             ),
+            default_case,
         ]
         nested_match: ast.stmt = ast.Match(
             subject=subject,
@@ -753,10 +994,12 @@ def _make_nested_match_for_multiple_let(
 
 # Multiple patterns are combined into nested match statements.
 def _make_if_let_multiple(
+    decl_type: str,
     pattern_subjects: list[tuple[ast.pattern, ast.expr]],
     cond: ast.expr | None,
     body: list[ast.stmt],
     orelse: list[ast.stmt] | None,
+    is_let_else: bool,
     **kwargs: Unpack[PosAttributes],
 ) -> ast.If:
     """
@@ -777,19 +1020,49 @@ def _make_if_let_multiple(
                                 match <subjectN>:
                                     case <patternN> if <cond>:
                                         <body>
+                                    case _:
+                                        pass
+                            ...
+                        case _:
+                            pass
+                case _:
+                    pass
         else:
             <orelse>
     """
     # Build nested match statements from inside out.
+    is_all_pattern_irrefutable = all(
+        is_pattern_irrefutable(pat) for pat, _ in pattern_subjects
+    )
+    is_all_pattern_truly_irrefutable = all(
+        is_pattern_irrefutable(pat, assume_type_checked=False)
+        for pat, _ in pattern_subjects
+    )
     result = ast.If(
         test=ast.Constant(value=True, **kwargs),
         body=_make_nested_match_for_multiple_let(
-            pattern_subjects, cond, body, **kwargs
+            decl_type,
+            pattern_subjects,
+            cond,
+            body,
+            type_error_on_failure=(
+                is_let_else
+                and (orelse is None)
+                and (not is_all_pattern_truly_irrefutable)
+            ),
+            is_let_else=is_let_else,
+            **kwargs,
         ),
         orelse=orelse or [],
         **kwargs,
     )
-    set_let_pattern_body(result, body)
+    set_let_pattern_body(
+        result,
+        LetPatternInfo(
+            body=body,
+            is_all_pattern_irrefutable=is_all_pattern_irrefutable,
+        ),
+    )
     return result
 
 
@@ -842,12 +1115,20 @@ def _make_while_let(
     result = ast.While(
         test=ast.Constant(value=True, **kwargs),
         body=_make_nested_match_for_multiple_let(
-            pattern_subjects, cond, body, **kwargs
+            "let", pattern_subjects, cond, body, False, False, **kwargs
         ),
         orelse=orelse or [],
         **kwargs,
     )
-    set_let_pattern_body(result, body)
+    set_let_pattern_body(
+        result,
+        LetPatternInfo(
+            body=body,
+            is_all_pattern_irrefutable=all(
+                is_pattern_irrefutable(pat) for pat, _ in pattern_subjects
+            ),
+        ),
+    )
     return result
 
 
@@ -1358,6 +1639,7 @@ def make_if_let_comp(
         args=_empty_args(),
         body=[
             make_if_let(
+                "let",
                 pattern_subjects,
                 cond,
                 [ast.Return(value=body, **get_pos_attributes(body))],
@@ -1563,10 +1845,8 @@ def clear_is_placeholder(node: ast.Name) -> None:
 
 _RECORD_LITERAL_FIELDS = "_typh_is_record_literal_fields"
 _RECORD_TYPE = "_typh_is_record_literal_type"
-_RECORD_PATTERN = "_typh_is_record_pattern"
 type RecordLiteral = ast.Name
 type RecordType = ast.Name
-type RecordPatternClass = ast.Name
 
 
 def set_record_literal_fields(
@@ -1637,24 +1917,29 @@ def make_record_type(
     return result
 
 
-def set_is_record_pattern(node: ast.Name, is_record_pattern: bool) -> ast.expr:
-    setattr(node, _RECORD_PATTERN, is_record_pattern)
+_ATTRIBUTES_PATTERN = "_typh_is_attributes_pattern"
+type AttributesPatternClass = ast.Name
+
+
+def set_is_attributes_pattern(node: ast.Name, is_record_pattern: bool) -> ast.expr:
+    setattr(node, _ATTRIBUTES_PATTERN, is_record_pattern)
     return node
 
 
-def is_record_pattern(node: ast.Name) -> bool:
-    return getattr(node, _RECORD_PATTERN, None) is not None
+def is_attributes_pattern(node: ast.Name) -> bool:
+    return getattr(node, _ATTRIBUTES_PATTERN, None) is not None
 
 
-def clear_is_record_pattern(node: ast.Name) -> None:
-    if hasattr(node, _RECORD_PATTERN):
-        delattr(node, _RECORD_PATTERN)
+def clear_is_attributes_pattern(node: ast.Name) -> None:
+    if hasattr(node, _ATTRIBUTES_PATTERN):
+        delattr(node, _ATTRIBUTES_PATTERN)
 
 
-def make_record_pattern(
+def make_attributes_pattern(
     keywords: list[tuple[str, ast.pattern]],
     **kwargs: Unpack[PosAttributes],
 ) -> ast.MatchClass:
+    debug_verbose_print(f"Creating attributes pattern with keywords: {keywords}")
     kwd_attrs = [k for k, _ in keywords]
     kwd_patterns = [
         (
@@ -1666,17 +1951,19 @@ def make_record_pattern(
         for k, p in keywords
     ]
     cls_name = ast.Name(
-        id="__record_pattern",
+        id="__attribute_pattern",
         **kwargs,
     )
-    set_is_record_pattern(cls_name, True)
-    return ast.MatchClass(
+    set_is_attributes_pattern(cls_name, True)
+    result = ast.MatchClass(
         cls=cls_name,
         patterns=[],
         kwd_attrs=kwd_attrs,
         kwd_patterns=kwd_patterns,
         **pos_attribute_to_range(kwargs),
     )
+    debug_verbose_print(f"Created attributes pattern: {ast.dump(result)}")
+    return result
 
 
 def if_comp_exp(
@@ -1699,7 +1986,25 @@ def get_postfix_operator_temp_name(symbol: str) -> str:
         raise ValueError(f"Unknown postfix operator symbol: {symbol}")
 
 
+_IMPORTS = "_typh_imports"
+
+
+def get_imports(mod: ast.Module) -> dict[tuple[str, str], ast.alias]:
+    imports: dict[tuple[str, str], ast.alias] | None = getattr(mod, _IMPORTS, None)
+    if imports is None:
+        imports = {}
+        setattr(mod, _IMPORTS, imports)
+    return imports
+
+
 def add_import_alias_top(mod: ast.Module, from_module: str, name: str, as_name: str):
+    debug_verbose_print(f"Adding import: from {from_module} import {name} as {as_name}")
+    # Check if already imported.
+    imports = get_imports(mod)
+    if (from_module, name) in imports and imports[
+        (from_module, name)
+    ].asname == as_name:
+        return
     # Duplicate import is NOT a problem, but better to avoid it for speed.
     for stmt in mod.body:
         if isinstance(stmt, ast.ImportFrom):
@@ -1710,28 +2015,73 @@ def add_import_alias_top(mod: ast.Module, from_module: str, name: str, as_name:
         else:
             break  # Only check the top sequence of import statements.
     # Add import at the top.
+    alias = ast.alias(name=name, asname=as_name, **get_empty_pos_attributes())
+    imports[(from_module, name)] = alias
     import_stmt = ast.ImportFrom(
         module=from_module,
-        names=[
-            ast.alias(
-                name=name,
-                asname=as_name,
-                **get_empty_pos_attributes(),
-            )
-        ],
+        names=[alias],
         level=0,
         **get_empty_pos_attributes(),
     )
     mod.body.insert(0, import_stmt)
 
 
-def is_pattern_irrefutable(pattern: ast.pattern) -> bool:
+_PATTERN_IS_TUPLE = "_typh_pattern_is_tuple"
+
+
+def set_pattern_is_tuple(pattern: ast.pattern, is_tuple: bool = True) -> ast.pattern:
+    setattr(pattern, _PATTERN_IS_TUPLE, is_tuple)
+    return pattern
+
+
+def is_pattern_tuple(pattern: ast.pattern) -> bool:
+    return getattr(pattern, _PATTERN_IS_TUPLE, False)
+
+
+def clear_pattern_is_tuple(pattern: ast.pattern) -> None:
+    if hasattr(pattern, _PATTERN_IS_TUPLE):
+        delattr(pattern, _PATTERN_IS_TUPLE)
+
+
+def make_tuple_pattern(
+    patterns: list[ast.pattern],
+    **kwargs: Unpack[PosAttributes],
+) -> ast.MatchSequence:
+    result = ast.MatchSequence(
+        patterns=patterns,
+        **pos_attribute_to_range(kwargs),
+    )
+    set_pattern_is_tuple(result, True)
+    return result
+
+
+def is_pattern_irrefutable(
+    pattern: ast.pattern, assume_type_checked: bool = True
+) -> bool:
     if isinstance(pattern, ast.MatchAs):
-        if pattern.pattern is None:
+        if pattern.pattern is None:  # Wildcard pattern or variable capture.
             return True
         return is_pattern_irrefutable(pattern.pattern)
     if isinstance(pattern, ast.MatchOr):
         return any(is_pattern_irrefutable(p) for p in pattern.patterns)
+    if assume_type_checked:  # Irrefutable if type is correct.
+        if isinstance(pattern, ast.MatchClass):
+            for p in pattern.patterns:
+                if not is_pattern_irrefutable(p, assume_type_checked):
+                    return False
+            for p in pattern.kwd_patterns:
+                if not is_pattern_irrefutable(p, assume_type_checked):
+                    return False
+            return True
+        if isinstance(pattern, ast.MatchSequence):
+            # Sequence is in general refutable due to length mismatch,
+            # but if we assume tuple is type-checked, we can consider it irrefutable.
+            if is_pattern_tuple(pattern):
+                for p in pattern.patterns:
+                    if not is_pattern_irrefutable(p, assume_type_checked):
+                        return False
+                return True
+    # Other patterns are considered refutable.
     return False