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

Typhon/Grammar/typhon_ast.py

@@ -1,10 +1,26 @@
 # Ast Extensions for Typhon
-
+from __future__ import annotations
+from re import A
+from typing import (
+    Union,
+    Unpack,
+    TypedDict,
+    Tuple,
+    cast,
+    TYPE_CHECKING,
+    Optional,
+    List,
+    Any,
+)
 import ast
-from typing import Union, Unpack, TypedDict, Tuple, cast
+from dataclasses import dataclass
 from copy import copy
+from tokenize import TokenInfo
 from ..Driver.debugging import debug_print, debug_verbose_print
 
+if TYPE_CHECKING:
+    from .parser_helper import Parser
+
 
 # Same as ast module's position attributes
 class PosAttributes(TypedDict):
@@ -14,6 +30,25 @@ class PosAttributes(TypedDict):
     end_col_offset: int | None
 
 
+def unpack_pos_default(pos: PosAttributes) -> Tuple[int, int, int, int]:
+    return (
+        pos["lineno"],
+        pos["col_offset"],
+        pos["end_lineno"] or pos["lineno"],
+        pos["end_col_offset"] or pos["col_offset"] + 1,
+    )
+
+
+def unpack_pos_tuple(pos: PosAttributes) -> Tuple[Tuple[int, int], Tuple[int, int]]:
+    return (
+        (pos["lineno"], pos["col_offset"]),
+        (
+            pos["end_lineno"] or pos["lineno"],
+            pos["end_col_offset"] or pos["col_offset"] + 1,
+        ),
+    )
+
+
 class PosRange(TypedDict):
     lineno: int
     col_offset: int
@@ -45,13 +80,21 @@ type PosNode = (
     | ast.excepthandler
     | ast.pattern
     | ast.keyword
+    | ast.match_case
 )
 
 
-def get_pos_attributes(node: PosNode) -> PosAttributes:
+def get_pos_attributes(node: PosNode | TokenInfo) -> PosAttributes:
+    if isinstance(node, TokenInfo):
+        return PosAttributes(
+            lineno=node.start[0],
+            col_offset=node.start[1],
+            end_lineno=node.end[0],
+            end_col_offset=node.end[1],
+        )
     return PosAttributes(
-        lineno=node.lineno,
-        col_offset=node.col_offset,
+        lineno=getattr(node, "lineno", 1),
+        col_offset=getattr(node, "col_offset", 0),
         end_lineno=getattr(node, "end_lineno", None),
         end_col_offset=getattr(node, "end_col_offset", None),
     )
@@ -69,14 +112,101 @@ def get_pos_attributes_if_exists(node: ast.AST) -> PosAttributes | None:
 
 
 def get_empty_pos_attributes() -> PosAttributes:
+    # Python ast position is 1-based for line, 0-based for column
     return PosAttributes(
-        lineno=0,
+        lineno=1,
         col_offset=0,
-        end_lineno=0,
+        end_lineno=1,
         end_col_offset=0,
     )
 
 
+_ANONYMOUS_NAME = "_typh_anonymous"
+
+
+def set_anonymous_name_id(node: ast.Name, id: int) -> ast.Name:
+    setattr(node, _ANONYMOUS_NAME, id)
+    return node
+
+
+def get_anonymous_base_name() -> str:
+    return _ANONYMOUS_NAME
+
+
+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 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_INVALID_NAME = "_typh_invalid_name"
+
+
+def get_invalid_name() -> str:
+    return _TYPE_INVALID_NAME
+
+
+_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)
+
+
+# The name is internal when it has no counterpart in input typhon source code.
+_INTERNAL_NAME = "_typh_internal_name"
+
+
+def is_internal_name(name: ast.Name) -> bool:
+    return getattr(name, _INTERNAL_NAME, False)
+
+
+def set_is_internal_name(name: ast.Name, is_internal: bool = True) -> ast.Name:
+    setattr(name, _INTERNAL_NAME, is_internal)
+    return name
+
+
+def clear_internal_name(name: ast.Name) -> None:
+    if hasattr(name, _INTERNAL_NAME):
+        delattr(name, _INTERNAL_NAME)
+
+
 # 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 +223,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 +535,106 @@ def declaration_as_withitem(assign: Union[ast.Assign, ast.AnnAssign]) -> ast.wit
         return item
 
 
+def _make_with_let_pattern(
+    parser: Parser,
+    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 = parser.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(
+    parser: Parser,
+    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(
+        parser,
+        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(
+    parser: Parser,
+    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(
+        parser,
+        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
 
@@ -419,6 +655,7 @@ def set_function_literal_def(
 ):
     setattr(name, _FUNC_DEF, func_def)
     setattr(func_def, _IS_FUNCTION_LITERAL, True)
+    set_is_internal_name(name)
 
 
 def clear_function_literal_def(name: FunctionLiteral):
@@ -628,6 +865,43 @@ def make_for_stmt(
         return result
 
 
+def make_for_let_pattern(
+    parser: Parser,
+    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 = parser.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 +915,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 +937,43 @@ 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 _let_pattern_check(
+    parser: Parser,
+    decl_type_str: str,
+    pattern_subjects: list[tuple[ast.pattern, ast.expr]],
+    start_pos: tuple[int, int],
+    end_pos: tuple[int, int],
+) -> bool:
+    if decl_type_str != "let":
+        error = parser.build_syntax_error(
+            "declaration pattern must be 'let' declaration", start_pos, end_pos
+        )
+    if len(pattern_subjects) == 0:
+        parser.build_syntax_error(
+            "declaration pattern must have at least one pattern", start_pos, end_pos
+        )
+    return True
+
+
 def make_if_let(
+    decl_type: TokenInfo | str,
     pattern_subjects: list[tuple[ast.pattern, ast.expr]],
     cond: ast.expr | None,
     body: list[ast.stmt],
@@ -679,27 +981,24 @@ def make_if_let(
     is_let_else: bool,
     **kwargs: Unpack[PosAttributes],
 ) -> 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),
-            is_let_else,
-        )
+    decl_type_str = decl_type.string if isinstance(decl_type, TokenInfo) else decl_type
+    return set_is_let_else(
+        _make_if_let_multiple(
+            decl_type_str, 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 +1008,65 @@ 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(
+            make_match_case(
+                pattern=pattern,
+                guard=_make_none_check(pattern.name, get_pos_attributes(pattern)),
+                body=body,
+                **get_pos_attributes(pattern),
+            ),
+            is_let_else,
         )
     else:
-        return ast.match_case(
-            pattern=pattern,
-            guard=cond,
-            body=body,
+        return set_is_let_else(
+            make_match_case(
+                pattern=pattern, guard=cond, body=body, **get_pos_attributes(pattern)
+            ),
+            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 +1080,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 +1106,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
 
 
@@ -800,10 +1159,7 @@ def make_while_let(
     orelse: list[ast.stmt] | None,
     **kwargs: Unpack[PosAttributes],
 ) -> ast.While:
-    if len(pattern_subjects) == 0:
-        raise SyntaxError("if let must have at least one pattern")
-    else:
-        return _make_while_let(pattern_subjects, cond, body, orelse, **kwargs)
+    return _make_while_let(pattern_subjects, cond, body, orelse, **kwargs)
 
 
 def _make_while_let(
@@ -842,12 +1198,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
 
 
@@ -862,10 +1226,65 @@ def is_static(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
     return getattr(node, IS_STATIC, False)
 
 
+_DEFINED_NAME = "_typh_defined_name"
+DefinesName = (
+    ast.FunctionDef
+    | ast.AsyncFunctionDef
+    | ast.ClassDef
+    | ast.alias
+    | ast.Attribute
+    | ast.arg
+)
+
+
+def get_defined_name(node: DefinesName) -> ast.Name | None:
+    return getattr(node, _DEFINED_NAME, None)
+
+
+def set_defined_name(
+    node: DefinesName,
+    name: ast.Name,
+):
+    setattr(node, _DEFINED_NAME, name)
+
+
+def maybe_copy_defined_name[T: ast.AST](
+    from_node: T,
+    to_node: T,
+) -> T:
+    if not isinstance(from_node, DefinesName) or not isinstance(to_node, DefinesName):
+        return to_node
+    name = get_defined_name(from_node)
+    if name is not None:
+        set_defined_name(to_node, name)
+    return to_node
+
+
+def set_defined_name_token(
+    node: DefinesName, name: TokenInfo | ast.Name, ctx: ast.expr_context = ast.Store()
+):
+    if isinstance(name, TokenInfo):
+        name = ast.Name(
+            id=name.string,
+            lineno=name.start[0],
+            col_offset=name.start[1],
+            end_lineno=name.end[0],
+            end_col_offset=name.end[1],
+            ctx=ctx,
+        )
+    setattr(node, _DEFINED_NAME, name)
+    return node
+
+
+def clear_defined_name(node: DefinesName):
+    if hasattr(node, _DEFINED_NAME):
+        delattr(node, _DEFINED_NAME)
+
+
 def make_function_def(
     is_async: bool,
     is_static: bool,
-    name: str,
+    name: TokenInfo | str,
     args: ast.arguments,
     returns: ast.expr | None,
     body: list[ast.stmt],
@@ -875,7 +1294,7 @@ def make_function_def(
 ) -> ast.FunctionDef | ast.AsyncFunctionDef:
     if is_async:
         result = ast.AsyncFunctionDef(
-            name=name,
+            name=name.string if isinstance(name, TokenInfo) else name,
             args=args,
             returns=returns,
             body=body,
@@ -885,7 +1304,7 @@ def make_function_def(
         )
     else:
         result = ast.FunctionDef(
-            name=name,
+            name=name.string if isinstance(name, TokenInfo) else name,
             args=args,
             returns=returns,
             body=body,
@@ -894,6 +1313,120 @@ def make_function_def(
             **kwargs,
         )
     set_is_static(result, is_static)
+    if isinstance(name, TokenInfo):
+        set_defined_name_token(result, name)
+    return result
+
+
+def make_class_def(
+    name: TokenInfo | str,
+    bases: list[ast.expr],
+    keywords: list[ast.keyword],
+    body: list[ast.stmt],
+    decorator_list: list[ast.expr],
+    type_params: list[ast.type_param],
+    **kwargs: Unpack[PosAttributes],
+) -> ast.ClassDef:
+    name_str = name.string if isinstance(name, TokenInfo) else name
+    result = ast.ClassDef(
+        name=name_str,
+        bases=bases,
+        keywords=keywords,
+        body=body,
+        decorator_list=decorator_list,
+        type_params=type_params,
+        **kwargs,
+    )
+    set_defined_name_token(
+        result,
+        name
+        if isinstance(name, TokenInfo)
+        else ast.Name(id=name, ctx=ast.Store(), **kwargs),
+    )
+    return result
+
+
+def make_alias(
+    name: list[TokenInfo],
+    asname: TokenInfo | None,
+    **kwargs: Unpack[PosAttributes],
+) -> ast.alias:
+    result = ast.alias(
+        name=".".join(n.string for n in name),
+        asname=asname.string if asname else None,
+        **kwargs,
+    )
+    if asname is not None:
+        set_defined_name_token(result, asname)
+    else:
+        set_defined_name_token(result, name[-1])
+    return result
+
+
+def make_attribute(
+    value: ast.expr,
+    attr: TokenInfo,
+    ctx: ast.expr_context,
+    **kwargs: Unpack[PosAttributes],
+):
+    return set_defined_name_token(
+        ast.Attribute(
+            value=value,
+            attr=attr.string,
+            ctx=ctx,
+            **kwargs,
+        ),
+        attr,
+        ctx,
+    )
+
+
+_IMPORT_FROM_NAMES = "_typh_import_from_names"
+
+
+def get_import_from_names(node: ast.ImportFrom) -> list[ast.Name]:
+    return getattr(node, _IMPORT_FROM_NAMES, [])
+
+
+def set_import_from_names(
+    node: ast.ImportFrom,
+    names: list[ast.Name],
+):
+    setattr(node, _IMPORT_FROM_NAMES, names)
+
+
+def clear_import_from_names(node: ast.ImportFrom):
+    if hasattr(node, _IMPORT_FROM_NAMES):
+        delattr(node, _IMPORT_FROM_NAMES)
+
+
+# Used only the case module part exists.
+def make_import_from(
+    module: list[TokenInfo] | None,
+    names: list[ast.alias],
+    level: int,
+    **kwargs: Unpack[PosAttributes],
+) -> ast.ImportFrom:
+    mod_name = ".".join(n.string for n in module) if module else None
+    result = ast.ImportFrom(
+        module=mod_name,
+        names=names,
+        level=level,
+        **kwargs,
+    )
+    if module:
+        import_names = [
+            ast.Name(
+                id=n.string,
+                lineno=n.start[0],
+                col_offset=n.start[1],
+                end_lineno=n.end[0],
+                end_col_offset=n.end[1],
+                ctx=ast.Load(),
+            )
+            for n in module
+        ]
+        set_import_from_names(result, import_names)
     return result
 
 
@@ -915,6 +1448,7 @@ def set_control_comprehension_def(
     node: ControlComprehension, func_def: ast.FunctionDef | ast.AsyncFunctionDef
 ):
     setattr(node, _CONTROL_COMPREHENSION, func_def)
+    set_is_internal_name(node)
 
 
 def clear_is_control_comprehension(node: ControlComprehension) -> None:
@@ -1283,7 +1817,7 @@ def make_match_comp(
             ast.Match(
                 subject=subject,
                 cases=[
-                    ast.match_case(
+                    make_match_case(
                         pattern=get_case_comp_case(case)[0],
                         guard=get_case_comp_case(case)[1],
                         body=[
@@ -1292,6 +1826,7 @@ def make_match_comp(
                                 **get_pos_attributes(case),
                             )
                         ],
+                        **get_pos_attributes(case),
                     )
                     for case in cases
                 ],
@@ -1358,6 +1893,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 +2099,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 +2171,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 +2205,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 +2240,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 +2269,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
 
 
@@ -1739,3 +2343,77 @@ def is_case_irrefutable(case: ast.match_case) -> bool:
     if case.guard:
         return False
     return is_pattern_irrefutable(case.pattern)
+
+
+def make_match_case(
+    pattern: ast.pattern,
+    guard: ast.expr | None,
+    body: list[ast.stmt],
+    **kwargs: Unpack[PosAttributes],
+) -> ast.match_case:
+    node = ast.match_case(pattern=pattern, guard=guard, body=body)
+    # Append position attributes
+    for key, value in kwargs.items():
+        setattr(node, key, value)
+    return node
+
+
+def make_arg(
+    arg: TokenInfo | None,
+    annotation: ast.expr | None,
+    **kwargs: Unpack[PosAttributes],
+):
+    """Build a function definition argument."""
+    node = ast.arg(
+        arg=arg.string if arg else "",
+        annotation=annotation,
+        **kwargs,
+    )
+    if arg:
+        set_defined_name_token(node, arg)
+    return node
+
+
+def make_arguments(
+    pos_only: Optional[List[Tuple[ast.arg, None]]],
+    pos_only_with_default: List[Tuple[ast.arg, Any]],
+    param_no_default: Optional[List[ast.arg]],
+    param_default: Optional[List[Tuple[ast.arg, Any]]],
+    after_star: Optional[
+        Tuple[Optional[ast.arg], List[Tuple[ast.arg, Any]], Optional[ast.arg]]
+    ],
+    **kwargs: Unpack[PosAttributes],
+) -> ast.arguments:
+    """Build a function definition arguments."""
+    defaults = (
+        [d for _, d in pos_only_with_default if d is not None]
+        if pos_only_with_default
+        else []
+    )
+    defaults += [d for _, d in param_default if d is not None] if param_default else []
+
+    pos_only = pos_only or pos_only_with_default
+
+    # Because we need to combine pos only with and without default even
+    # the version with no default is a tuple
+    pos_only_args = [p for p, _ in pos_only]
+    params = (param_no_default or []) + (
+        [p for p, _ in param_default] if param_default else []
+    )
+
+    # If after_star is None, make a default tuple
+    after_star = after_star or (None, [], None)
+
+    node = ast.arguments(
+        posonlyargs=pos_only_args,
+        args=params,
+        defaults=defaults,
+        vararg=after_star[0],
+        kwonlyargs=[p for p, _ in after_star[1]],
+        kw_defaults=[d for _, d in after_star[1]],
+        kwarg=after_star[2],
+    )
+    # Append position attributes
+    for key, value in kwargs.items():
+        setattr(node, key, value)
+    return node