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

Typhon/Transform/record_to_dataclass.py

@@ -10,25 +10,21 @@ from ..Grammar.typhon_ast import (
     set_is_var,
     is_record_literal,
     is_record_type,
-    is_record_pattern,
+    is_attributes_pattern,
 )
 from .visitor import TyphonASTVisitor, TyphonASTTransformer, flat_append
-from .utils import (
-    add_import_for_dataclass,
-    add_import_for_protocol,
-    add_import_for_runtime_checkable,
-    add_import_for_final,
+from .utils.imports import (
     get_insert_point_for_class,
 )
+from .utils.make_class import (
+    make_dataclass_protocol_definition,
+    make_dataclass_definition,
+    NameAndAnnotation,
+)
 from dataclasses import dataclass
 from typing import Protocol, Iterable, Final
 
 
-class NameAndAnnotation(Protocol):
-    name: Final[ast.Name]
-    annotation: Final[ast.expr]
-
-
 @dataclass
 class RecordFieldInfo:
     name: ast.Name
@@ -59,31 +55,14 @@ class RecordTypeInfo:
     type_variables: list[str]
 
 
-@dataclass
-class RecordPatternFieldInfo:
-    name: ast.Name
-    annotation: ast.expr
-
-
-@dataclass
-class RecordPatternInfo:
-    class_name: str
-    pattern: ast.MatchClass
-    record: ast.Name
-    type_variables: list[str]
-    fields: list[RecordPatternFieldInfo]
-
-
 class _GatherRecords(TyphonASTVisitor):
     records: list[RecordInfo]
     record_types: list[RecordTypeInfo]
-    record_patterns: list[RecordPatternInfo]
 
     def __init__(self, module: ast.Module):
         super().__init__(module)
         self.records = []
         self.record_types = []
-        self.record_patterns = []
 
     def _visit_RecordLiteral(self, node: RecordLiteral):
         fields = get_record_literal_fields(node)
@@ -107,7 +86,7 @@ class _GatherRecords(TyphonASTVisitor):
         type_fields = get_record_type_fields(node)
         if not type_fields:
             return
-        type_vars = []
+        type_vars: list[str] = []
         field_infos: list[RecordTypeFieldInfo] = []
         for name, annotation in type_fields:
             # Always create a new type variable for each field so that scoped type
@@ -134,100 +113,9 @@ class _GatherRecords(TyphonASTVisitor):
             self._visit_RecordType(node)
         return self.generic_visit(node)
 
-    def visit_MatchClass(self, node: ast.MatchClass):
-        if isinstance(node.cls, ast.Name) and is_record_pattern(node.cls):
-            record_cls = node.cls
-            type_vars = []
-            fields: list[RecordPatternFieldInfo] = []
-            # 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(
-                    RecordPatternFieldInfo(
-                        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(
-                RecordPatternInfo(
-                    self.new_class_name(""),
-                    node,
-                    record_cls,
-                    type_vars,
-                    fields,
-                )
-            )
-        return self.generic_visit(node)
-
-
-def _dataclass_decorator(
-    dataclass_imported_name: str, repr: bool, pos: PosAttributes
-) -> ast.expr:
-    return ast.Call(
-        func=ast.Name(id=dataclass_imported_name, ctx=ast.Load(), **pos),
-        args=[],
-        keywords=[
-            ast.keyword(arg="frozen", value=ast.Constant(value=True)),
-            ast.keyword(arg="repr", value=ast.Constant(value=repr)),
-            ast.keyword(arg="unsafe_hash", value=ast.Constant(value=True)),
-            ast.keyword(arg="kw_only", value=ast.Constant(value=True)),
-        ],
-    )
-
-
-def _class_contents_for_fields(
-    fields: Iterable[NameAndAnnotation],
-    final_imported_name: str,
-) -> list[ast.stmt]:
-    result: list[ast.stmt] = []
-    for field in fields:
-        name = field.name
-        if field.annotation:
-            annotation = ast.Subscript(
-                value=ast.Name(
-                    id=final_imported_name, ctx=ast.Load(), **get_pos_attributes(name)
-                ),
-                slice=field.annotation,
-                ctx=ast.Load(),
-                **get_pos_attributes(name),
-            )
-        else:
-            annotation = ast.Name(
-                id=final_imported_name, ctx=ast.Load(), **get_pos_attributes(name)
-            )
-        ann_assign = ast.AnnAssign(
-            target=ast.Name(id=name.id, ctx=ast.Store(), **get_pos_attributes(name)),
-            annotation=annotation,
-            value=None,
-            simple=1,
-            **get_pos_attributes(name),
-        )
-        # "var" because dataclass is frozen, "Final" is not required.
-        set_is_var(ann_assign)
-        result.append(ann_assign)
-    return result
-
-
-def _type_vars_for_fields(
-    record: ast.Name, type_variables: list[str]
-) -> list[ast.type_param]:
-    type_params: list[ast.type_param] = []
-    for tv in type_variables:
-        type_params.append(
-            ast.TypeVar(name=tv, **pos_attribute_to_range(get_pos_attributes(record)))
-        )
-    return type_params
-
 
 def _add_repr_to_dataclass(
-    class_def: ast.ClassDef, record: ast.Name, fields: list[RecordFieldInfo]
+    class_def: ast.ClassDef, record: ast.Name, fields: Iterable[NameAndAnnotation]
 ):
     repr_values: list[ast.expr] = []
     for i, field in enumerate(fields):
@@ -275,65 +163,6 @@ def _add_repr_to_dataclass(
     class_def.body.append(repr_func_def)
 
 
-def _make_dataclass_definition(
-    info: RecordInfo,
-    dataclass_imported_name: str,
-    final_imported_name: str,
-) -> ast.ClassDef:
-    result = ast.ClassDef(
-        name=info.class_name,
-        type_params=_type_vars_for_fields(info.record, info.type_variables),
-        bases=[],
-        keywords=[],
-        body=_class_contents_for_fields(info.fields, final_imported_name),
-        decorator_list=[
-            _dataclass_decorator(
-                dataclass_imported_name, repr=False, pos=get_pos_attributes(info.record)
-            )
-        ],
-        **get_pos_attributes(info.record),
-    )
-    _add_repr_to_dataclass(result, info.record, info.fields)
-    return result
-
-
-def _make_dataclass_protocol_definition(
-    class_name: str,
-    type_variables: list[str],
-    record: ast.Name,
-    fields: Iterable[NameAndAnnotation],
-    dataclass_imported_name: str,
-    protocol_imported_name: str,
-    runtime_checkable_imported_name: str,
-    final_imported_name: str,
-) -> ast.ClassDef:
-    result = ast.ClassDef(
-        name=class_name,
-        type_params=_type_vars_for_fields(record, type_variables),
-        bases=[
-            ast.Name(
-                id=protocol_imported_name,
-                ctx=ast.Load(),
-                **get_pos_attributes(record),
-            )
-        ],
-        keywords=[],
-        body=_class_contents_for_fields(fields, final_imported_name),
-        decorator_list=[
-            ast.Name(
-                id=runtime_checkable_imported_name,
-                ctx=ast.Load(),
-                **get_pos_attributes(record),
-            ),
-            _dataclass_decorator(
-                dataclass_imported_name, repr=True, pos=get_pos_attributes(record)
-            ),
-        ],
-        **get_pos_attributes(record),
-    )
-    return result
-
-
 class _Transform(TyphonASTTransformer):
     def __init__(
         self,
@@ -342,16 +171,12 @@ class _Transform(TyphonASTTransformer):
         info_for_record: dict[ast.Name, RecordInfo],
         class_for_record_type: dict[ast.Name, ast.ClassDef],
         info_for_record_type: dict[ast.Name, RecordTypeInfo],
-        class_for_record_pattern: dict[ast.Name, ast.ClassDef],
-        info_for_record_pattern: dict[ast.Name, RecordPatternInfo],
     ):
         super().__init__(module)
         self.class_for_record = class_for_record
         self.info_for_record = info_for_record
         self.class_for_record_type = class_for_record_type
         self.info_for_record_type = info_for_record_type
-        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:
@@ -383,12 +208,6 @@ class _Transform(TyphonASTTransformer):
                     **get_empty_pos_attributes(),
                 ),
             )
-        elif 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)
 
 
@@ -396,70 +215,37 @@ class _Transform(TyphonASTTransformer):
 def record_to_dataclass(module: ast.Module):
     gatherer = _GatherRecords(module)
     gatherer.run()
-    if (
-        not gatherer.records
-        and not gatherer.record_types
-        and not gatherer.record_patterns
-    ):
+    if not gatherer.records and not gatherer.record_types:
         return
-    # Add imports
-    dataclass_imported_name = add_import_for_dataclass(module)
-    final_imported_name = add_import_for_final(module)
-    protocol_imported_name = ""
-    runtime_checkable_imported_name = ""
-    if gatherer.record_types or gatherer.record_patterns:
-        protocol_imported_name = add_import_for_protocol(module)
-        runtime_checkable_imported_name = add_import_for_runtime_checkable(module)
     # Create class and information for each record literal.
     class_for_record: dict[ast.Name, ast.ClassDef] = {}
     info_for_record: dict[ast.Name, RecordInfo] = {}
-    insert_point = get_insert_point_for_class(module)
     for info in gatherer.records:
-        class_def = _make_dataclass_definition(
-            info,
-            dataclass_imported_name,
-            final_imported_name,
+        class_def = make_dataclass_definition(
+            module,
+            info.class_name,
+            info.type_variables,
+            info.fields,
+            get_pos_attributes(info.record),
         )
+        _add_repr_to_dataclass(class_def, info.record, info.fields)
         class_for_record[info.record] = class_def
         info_for_record[info.record] = info
-        module.body.insert(insert_point, class_def)
-        insert_point += 1
+        module.body.insert(get_insert_point_for_class(module), class_def)
     # Create class and information for each record type.
     class_for_record_type: dict[ast.Name, ast.ClassDef] = {}
     info_for_record_type: dict[ast.Name, RecordTypeInfo] = {}
     for info in gatherer.record_types:
-        class_def_type = _make_dataclass_protocol_definition(
+        class_def_type = make_dataclass_protocol_definition(
+            module,
             info.class_name,
             info.type_variables,
-            info.record,
             info.fields,
-            dataclass_imported_name,
-            protocol_imported_name,
-            runtime_checkable_imported_name,
-            final_imported_name,
+            get_pos_attributes(info.record),
         )
         class_for_record_type[info.record] = class_def_type
         info_for_record_type[info.record] = info
-        module.body.insert(insert_point, class_def_type)
-        insert_point += 1
-    # Create class and information for each record pattern.
-    class_for_record_pattern: dict[ast.Name, ast.ClassDef] = {}
-    info_for_record_pattern: dict[ast.Name, RecordPatternInfo] = {}
-    for info in gatherer.record_patterns:
-        class_def_type = _make_dataclass_protocol_definition(
-            info.class_name,
-            info.type_variables,
-            info.record,
-            info.fields,
-            dataclass_imported_name,
-            protocol_imported_name,
-            runtime_checkable_imported_name,
-            final_imported_name,
-        )
-        class_for_record_pattern[info.record] = class_def_type
-        info_for_record_pattern[info.record] = info
-        module.body.insert(insert_point, class_def_type)
-        insert_point += 1
+        module.body.insert(get_insert_point_for_class(module), class_def_type)
 
     _Transform(
         module,
@@ -467,6 +253,4 @@ def record_to_dataclass(module: ast.Module):
         info_for_record,
         class_for_record_type,
         info_for_record_type,
-        class_for_record_pattern,
-        info_for_record_pattern,
     ).run()

Typhon/Transform/scope_check_rename.py

@@ -13,6 +13,9 @@ from ..Grammar.typhon_ast import (
     is_inline_with,
     set_is_placeholder,
     get_type_annotation,
+    is_anonymous_name,
+    get_anonymous_name_id,
+    is_let_else,
 )
 from ..Grammar.syntax_errors import (
     raise_scope_error,
@@ -71,6 +74,7 @@ class SymbolScopeVisitor(TyphonASTVisitor):
         self.require_global: dict[str, set[PythonScope]] = {}
         self.require_nonlocal: dict[str, set[PythonScope]] = {}
         self.builtins_symbols = get_builtins()
+        self.anonymous_names: dict[int, str] = {}
 
     def _enter_scope(self):
         self.scopes.append({})
@@ -172,14 +176,28 @@ class SymbolScopeVisitor(TyphonASTVisitor):
         is_top_level = self.now_is_top_level(ignore_current=add_to_parent_python_scope)
         if is_top_level:
             self.resolve_suspended_resolves(name)
-        in_scope_non_python_top_level = len(self.scopes) > 1
+        considering_python_scopes = (
+            len(self.parent_python_scopes) - 1
+            if add_to_parent_python_scope
+            else len(self.parent_python_scopes)
+        )
+        in_scope_non_python_top_level = (
+            len(self.scopes) > considering_python_scopes and len(self.scopes) > 1
+        )
+        rename_condition = (
+            # To realize shadowing
+            self.is_shadowed(name, python_scope_to_add)
+            # To prevent to expose to top-level scope
+            or (is_top_level and in_scope_non_python_top_level)
+            or is_force_rename
+        )
+        if name not in self.builtins_symbols:
+            debug_verbose_print(
+                f"Renaming condition of '{name}': {rename_condition} is_shadowed={self.is_shadowed(name, python_scope_to_add)}, is_top_level={is_top_level}, in_scope_non_python_top_level={in_scope_non_python_top_level}, is_force_rename={is_force_rename}) len(scopes)={len(self.scopes)} len(parent_python_scopes)={len(self.parent_python_scopes)} rename_on_demand_to_kind={rename_on_demand_to_kind} "
+            )
         # Rename if required
         if rename_on_demand_to_kind is not None:
-            if (
-                self.is_shadowed(name, python_scope_to_add)
-                or (is_top_level and in_scope_non_python_top_level)
-                or is_force_rename
-            ):
+            if rename_condition:
                 new_name = self.new_name(rename_on_demand_to_kind, name)
                 dec.renamed_to = new_name
                 debug_print(f"Renamed variable '{dec.name}' to '{new_name}'")
@@ -437,19 +455,31 @@ class SymbolScopeVisitor(TyphonASTVisitor):
 
     def visit_Match(self, node: ast.Match):
         self.visit(node.subject)
-        self.visit_list_scoped(node.cases)
+        # self.visit_list_scoped(node.cases) # Each case has its own scope
+        for case in node.cases:
+            self.visit(case)
         return node
 
     # Match patterns. Basis of declarative patterns are MatchAs, MatchStar.
     # Other patterns are composed of these.
     # Declarations in patterns are immutable.
     def visit_match_case(self, node: ast.match_case):
-        with self.scope():
+        def visit_children():
             self.visit(node.pattern)
             if node.guard:
                 self.visit(node.guard)
             self.visit_list_scoped(node.body)
 
+        debug_verbose_print(
+            f"Visiting match_case: pattern={ast.dump(node)} is_let_else={is_let_else(node)}"
+        )
+
+        if is_let_else(node):
+            visit_children()
+        else:
+            with self.scope():
+                visit_children()
+
     def visit_MatchAs(self, node: ast.MatchAs):
         if node.pattern:
             self.visit(node.pattern)
@@ -459,7 +489,8 @@ class SymbolScopeVisitor(TyphonASTVisitor):
                 name,
                 is_mutable=False,
                 # Force rename to avoid conflict to other patterns when type annotations is specified, because they are expanded in the same scope.
-                is_force_rename=get_type_annotation(node) is not None,
+                is_force_rename=get_type_annotation(node) is not None
+                and len(self.scopes) > 1,
             )
             node.name = name.id
         return node
@@ -471,7 +502,8 @@ class SymbolScopeVisitor(TyphonASTVisitor):
                 name,
                 is_mutable=False,
                 # Force rename to avoid conflict to other patterns when type annotations is specified, because they are expanded in the same scope.
-                is_force_rename=get_type_annotation(node) is not None,
+                is_force_rename=get_type_annotation(node) is not None
+                and len(self.scopes) > 1,
             )
             node.name = name.id
         return node
@@ -696,9 +728,28 @@ class SymbolScopeVisitor(TyphonASTVisitor):
                 ast.Name(id=sym.name, ctx=ast.Store(), **get_empty_pos_attributes())
             )
 
+    def handle_anonymous_name(self, node: ast.Name):
+        anon_id = get_anonymous_name_id(node)
+        if anon_id is None:
+            return False
+        if anon_id in self.anonymous_names:
+            debug_verbose_print(
+                f"Reused anonymous variable for '{node.id}' as '{self.anonymous_names[anon_id]}'"
+            )
+            node.id = self.anonymous_names[anon_id]
+        else:
+            new_name = self.new_name(NameKind.VARIABLE, "")
+            debug_verbose_print(
+                f"Renamed anonymous variable '{node.id}' to '{new_name}'"
+            )
+            self.anonymous_names[anon_id] = new_name
+            node.id = new_name
+        return True
+
     # The main part of this visitor.
     # Variable reference and declaration. Rename if necessary.
     def visit_Name(self, node: ast.Name):
+        is_anon = self.handle_anonymous_name(node)
         if self.declaration_context:
             # Left-hand side of an declaration assignment
             if self.current_scope().get(node.id):
@@ -707,10 +758,13 @@ class SymbolScopeVisitor(TyphonASTVisitor):
                 node.id,
                 is_mutable=self.declaration_context.is_mutable,
                 pos=get_pos_attributes(node),
-                is_force_rename=self.declaration_context.is_force_rename,
+                is_force_rename=self.declaration_context.is_force_rename
+                and not is_anon,
                 rename_on_demand_to_kind=(
                     NameKind.VARIABLE
                     if self.declaration_context.is_mutable
+                    else None
+                    if is_anon
                     else NameKind.CONST
                 ),
             )

Typhon/Transform/transform.py

@@ -13,34 +13,38 @@ from .if_while_let import if_while_let_transform
 from .comprehension_to_function import comprehension_to_function
 from .placeholder_to_function import placeholder_to_func
 from .record_to_dataclass import record_to_dataclass
+from .extended_patterns import extended_protocol
 
 from ..Grammar.syntax_errors import raise_from_module_syntax_errors
+from ..Grammar.unparse_custom import unparse_custom
 
 
 def transform(mod: ast.Module):
     check_forbidden_statements(mod)
     record_to_dataclass(mod)
-    debug_verbose_print(f"After record_to_dataclass:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After record_to_dataclass:\n{unparse_custom(mod)}\n")
+    extended_protocol(mod)
+    debug_verbose_print(f"After extended_protocol:\n{unparse_custom(mod)}\n")
     inline_statement_block_capture(mod)
-    debug_print(f"After inline_statement_block_capture:\n{ast.unparse(mod)}\n")
+    debug_print(f"After inline_statement_block_capture:\n{unparse_custom(mod)}\n")
     if_while_let_transform(mod)
-    debug_verbose_print(f"After if_while_let_transform:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After if_while_let_transform:\n{unparse_custom(mod)}\n")
     insert_self_to_method(mod)
-    debug_verbose_print(f"After insert_self_to_method:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After insert_self_to_method:\n{unparse_custom(mod)}\n")
     comprehension_to_function(mod)
-    debug_verbose_print(f"After comprehension_to_function:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After comprehension_to_function:\n{unparse_custom(mod)}\n")
     func_literal_to_def(mod)
-    debug_print(f"After func_literal_to_def:\n{ast.unparse(mod)}\n")
+    debug_print(f"After func_literal_to_def:\n{unparse_custom(mod)}\n")
     scope_check_rename(mod)
-    debug_print(f"After scope_check_rename:\n{ast.unparse(mod)}\n")
+    debug_print(f"After scope_check_rename:\n{unparse_custom(mod)}\n")
     placeholder_to_func(mod)
-    debug_print(f"After placeholder_to_func:\n{ast.unparse(mod)}\n")
+    debug_print(f"After placeholder_to_func:\n{unparse_custom(mod)}\n")
     optional_to_checked(mod)
-    debug_verbose_print(f"After optional_to_checked:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After optional_to_checked:\n{unparse_custom(mod)}\n")
     type_annotation_check_expand(mod)
-    debug_verbose_print(f"After type_annotation_check_expand:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After type_annotation_check_expand:\n{unparse_custom(mod)}\n")
     type_abbrev_desugar(mod)
-    debug_verbose_print(f"After func_type_to_protocol:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After func_type_to_protocol:\n{unparse_custom(mod)}\n")
     const_member_to_final(mod)
-    debug_print(f"After transform:\n{ast.unparse(mod)}\n")
+    debug_print(f"After transform:\n{unparse_custom(mod)}\n")
     raise_from_module_syntax_errors(mod)

Typhon/Transform/type_abbrev_desugar.py

@@ -17,7 +17,7 @@ from ..Grammar.syntax_errors import (
     try_handle_syntax_error_or,
 )
 from .visitor import TyphonASTVisitor, TyphonASTTransformer
-from .utils import add_import_for_protocol, get_insert_point_for_class
+from .utils.imports import add_import_for_protocol, get_insert_point_for_class
 from ..Driver.debugging import debug_print, debug_verbose_print
 
 

Typhon/Transform/utils/imports.py

@@ -0,0 +1,48 @@
+from ...Grammar.typhon_ast import (
+    add_import_alias_top,
+    is_case_irrefutable,
+    get_pos_attributes,
+    pos_attribute_to_range,
+    set_is_var,
+)
+from ..name_generator import (
+    get_protocol_name,
+    get_final_name,
+    get_dataclass_name,
+    get_runtime_checkable_name,
+)
+import ast
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Protocol, Iterable, Final
+
+
+def add_import_for_protocol(mod: ast.Module):
+    name = get_protocol_name()
+    add_import_alias_top(mod, "typing", "Protocol", name)
+    return name
+
+
+def add_import_for_final(mod: ast.Module):
+    name = get_final_name()
+    add_import_alias_top(mod, "typing", "Final", name)
+    return name
+
+
+def add_import_for_dataclass(mod: ast.Module):
+    name = get_dataclass_name()
+    add_import_alias_top(mod, "dataclasses", "dataclass", name)
+    return name
+
+
+def add_import_for_runtime_checkable(mod: ast.Module):
+    name = get_runtime_checkable_name()
+    add_import_alias_top(mod, "typing", "runtime_checkable", name)
+    return name
+
+
+def get_insert_point_for_class(module: ast.Module) -> int:
+    for index, stmt in enumerate(module.body):
+        if not isinstance(stmt, (ast.Import, ast.ImportFrom)):
+            return index
+    return len(module.body)

Typhon/Transform/{utils.py → utils/jump_away.py}

@@ -1,46 +1,9 @@
-from ..Grammar.typhon_ast import add_import_alias_top, is_case_irrefutable
-from .name_generator import (
-    get_protocol_name,
-    get_final_name,
-    get_dataclass_name,
-    get_runtime_checkable_name,
-)
+from ...Grammar.typhon_ast import is_case_irrefutable
 import ast
 from contextlib import contextmanager
 from dataclasses import dataclass
 
 
-def add_import_for_protocol(mod: ast.Module):
-    name = get_protocol_name()
-    add_import_alias_top(mod, "typing", "Protocol", name)
-    return name
-
-
-def add_import_for_final(mod: ast.Module):
-    name = get_final_name()
-    add_import_alias_top(mod, "typing", "Final", name)
-    return name
-
-
-def add_import_for_dataclass(mod: ast.Module):
-    name = get_dataclass_name()
-    add_import_alias_top(mod, "dataclasses", "dataclass", name)
-    return name
-
-
-def add_import_for_runtime_checkable(mod: ast.Module):
-    name = get_runtime_checkable_name()
-    add_import_alias_top(mod, "typing", "runtime_checkable", name)
-    return name
-
-
-def get_insert_point_for_class(module: ast.Module) -> int:
-    for index, stmt in enumerate(module.body):
-        if not isinstance(stmt, (ast.Import, ast.ImportFrom)):
-            return index
-    return len(module.body)
-
-
 @dataclass
 class _Loop:
     node: ast.AST
@@ -117,6 +80,7 @@ class _JumpAwayVisitor(ast.NodeVisitor):
         return jump_away
 
     def visit_Match(self, node: ast.Match):
+        # Check that all cases jump away, and at least one is irrefutable.
         jump_away = True
         found_irrefutable = False
         for case in node.cases: