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

Typhon/SourceMap/datatype.py

@@ -5,6 +5,8 @@ from intervaltree import IntervalTree, Interval
 from typing import Iterable
 import ast
 
+from basedpyright.langserver import main
+
 
 @dataclass(frozen=True, unsafe_hash=True, order=True)
 class Pos:
@@ -69,7 +71,7 @@ class Pos:
         )
 
 
-# Common central datatype for source range
+# Common central datatype for source range. All are 0 based.
 @dataclass(frozen=True, unsafe_hash=True, order=True)
 class Range:
     start: Pos
@@ -98,17 +100,20 @@ class Range:
     @staticmethod
     def from_pos_range(pos_range: PosRange) -> "Range":
         return Range(
-            start=Pos(line=pos_range["lineno"], column=pos_range["col_offset"]),
-            end=Pos(line=pos_range["end_lineno"], column=pos_range["end_col_offset"]),
+            start=Pos(line=pos_range["lineno"] - 1, column=pos_range["col_offset"]),
+            end=Pos(
+                line=pos_range["end_lineno"] - 1, column=pos_range["end_col_offset"]
+            ),
         )
 
     @staticmethod
     def from_pos_attr(attr: PosAttributes) -> "Range | None":
+        # Python ast position is 1-based for line, 0-based for column
         if attr["end_lineno"] is None or attr["end_col_offset"] is None:
             return None
         return Range(
-            start=Pos(line=attr["lineno"], column=attr["col_offset"]),
-            end=Pos(line=attr["end_lineno"], column=attr["end_col_offset"]),
+            start=Pos(line=attr["lineno"] - 1, column=attr["col_offset"]),
+            end=Pos(line=attr["end_lineno"] - 1, column=attr["end_col_offset"]),
         )
 
     @staticmethod
@@ -126,8 +131,8 @@ class Range:
         if end_line == start_line and start_column == end_column:
             end_column += 1  # Ensure non-zero length
         return Range(
-            start=Pos(line=start_line, column=start_column),
-            end=Pos(line=end_line, column=end_column),
+            start=Pos(line=start_line - 1, column=start_column),
+            end=Pos(line=end_line - 1, column=end_column),
         )
 
     @staticmethod
@@ -143,13 +148,13 @@ class Range:
 
     @staticmethod
     def from_syntax_error(e: SyntaxError) -> "Range":
-        start_line = e.lineno or 0
+        start_line = e.lineno or 1
         start_column = e.offset or 0
         end_line = e.end_lineno or start_line
         end_column = e.end_offset or (start_column + 1)
         return Range(
-            start=Pos(line=start_line, column=start_column),
-            end=Pos(line=end_line, column=end_column),
+            start=Pos(line=start_line - 1, column=start_column),
+            end=Pos(line=end_line - 1, column=end_column),
         )
 
     @staticmethod
@@ -168,11 +173,10 @@ class Range:
         return self.of_lines(lines)
 
     def of_lines(self, lines: list[str]) -> str:
-        # Range is 1 based. Convert to 0 based for string slicing.
-        start_line = self.start.line - 1
-        end_line = self.end.line - 1
-        start_column = self.start.column - 1
-        end_column = self.end.column - 1
+        start_line = self.start.line
+        end_line = self.end.line
+        start_column = self.start.column
+        end_column = self.end.column
 
         def get_in_line(line: str, start_col: int, end_col: int) -> str:
             return line[start_col : min(end_col, len(line))]
@@ -190,6 +194,9 @@ class Range:
             result_lines.append(get_in_line(lines[end_line], 0, end_column))
             return "\n".join(result_lines)
 
+    def deconstruct_str(self):
+        return f"Range(Pos({self.start.line}, {self.start.column}), Pos({self.end.line}, {self.end.column}))"
+
 
 type RangeInterval[T] = tuple[Range, T]
 
@@ -247,6 +254,7 @@ class RangeIntervalTree[T]:
 
     def minimal_containers(self, range: Range) -> list[RangeInterval[T]]:
         containers = self._container_intervals(range)
+        debug_verbose_print(f"Minimal containers for range {range}: {containers}")
         if not containers:
             return []
         result: list[RangeInterval[T]] = []
@@ -255,10 +263,13 @@ class RangeIntervalTree[T]:
             is_minimal = True
             for j, other_interval in enumerate(containers):
                 if (
-                    i != j and interval.contains_interval(other_interval)  # type: ignore[misc]
+                    i != j
+                    and interval.contains_interval(other_interval)  # type: ignore[misc]
+                    and not interval.range_matches(other_interval)  # type: ignore[misc]
                 ):
                     is_minimal = False
                     break
             if is_minimal:
+                debug_verbose_print(f"  Minimal container: {interval}")
                 result.append((Range.from_interval(interval), interval.data))  # type: ignore[misc]
         return result

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.imports 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/forbidden_statements.py

@@ -85,6 +85,7 @@ class ForbiddenStatementChecker(TyphonASTVisitor):
                     ast.Import,
                     ast.AnnAssign,
                     ast.Assign,
+                    ast.Pass,
                 ),
             )
         ):

Typhon/Transform/optional_operators_to_checked.py

@@ -10,8 +10,10 @@ from ..Grammar.typhon_ast import (
     is_optional,
     is_optional_pipe,
     clear_is_optional,
+    get_defined_name,
+    maybe_copy_defined_name,
 )
-
+from ..Driver.debugging import debug_verbose_print
 from .visitor import TyphonASTTransformer
 from .name_generator import get_unwrap_name, get_unwrap_error_name
 
@@ -178,13 +180,19 @@ class _OptionalToCheckTransformer(TyphonASTTransformer):
         if not is_optional(node):
             return self.generic_visit(node)
         pos = get_pos_attributes(node)
+        debug_verbose_print(
+            f"Transforming optional attribute access at line {pos['lineno']}, col {pos['col_offset']} for attribute '{node.attr}' defined name: '{get_defined_name(node)}'"
+        )
         result = self._optional_check_if_exp(
             node.value,
-            lambda tmp_name: ast.Attribute(
-                value=ast.Name(id=tmp_name, ctx=ast.Load()),
-                attr=node.attr,
-                ctx=node.ctx,
-                **pos,
+            lambda tmp_name: maybe_copy_defined_name(
+                node,
+                ast.Attribute(
+                    value=ast.Name(id=tmp_name, ctx=ast.Load()),
+                    attr=node.attr,
+                    ctx=node.ctx,
+                    **pos,
+                ),
             ),
             ast.Constant(value=None, **pos),
             pos,

Typhon/Transform/scope_check_rename.py

@@ -45,10 +45,20 @@ class DeclarationContext:
 @dataclass
 class SuspendedResolveAccess:
     name: ast.Name
-    top_level_dead: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
+    temporally_dead_accessor: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
     is_mutation: bool
     accessor_python_scope: PythonScope
 
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.name.id,
+                id(self.temporally_dead_accessor),
+                self.is_mutation,
+                id(self.accessor_python_scope),
+            )
+        )
+
 
 def get_builtins() -> set[str]:
     builtin_syms = set(dir(builtins))
@@ -70,7 +80,9 @@ class SymbolScopeVisitor(TyphonASTVisitor):
         self.non_declaration_assign_context = False
         self.suspended_symbols: set[str] = set()
         # suspended_resolves[dead_accessor_name][undeclared_name]
-        self.suspended_resolves: dict[str, dict[str, list[SuspendedResolveAccess]]] = {}
+        # dead_accessor_name: Name of function/class which is in its TDZ.
+        # undeclared_name: Name which is undeclared used in dead_accessor.
+        self.suspended_resolves: dict[str, dict[str, set[SuspendedResolveAccess]]] = {}
         self.require_global: dict[str, set[PythonScope]] = {}
         self.require_nonlocal: dict[str, set[PythonScope]] = {}
         self.builtins_symbols = get_builtins()
@@ -623,19 +635,26 @@ class SymbolScopeVisitor(TyphonASTVisitor):
     type SuspendableScope = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
 
     def add_suspended_resolve(
-        self, name: ast.Name, top_level_dead: SuspendableScope, is_mutable: bool
+        self,
+        name: ast.Name,
+        temporally_dead_accessor: SuspendableScope,
+        is_mutable: bool,
     ) -> SuspendedResolveAccess:
-        tdz = SuspendedResolveAccess(
+        suspended = SuspendedResolveAccess(
             name=name,
-            top_level_dead=top_level_dead,
+            temporally_dead_accessor=temporally_dead_accessor,
             is_mutation=is_mutable,
             accessor_python_scope=self.get_parent_python_scope(),
         )
+        debug_verbose_print(
+            f" Adding suspended access to temporal dead variable '{name.id}' in top-level scope '{temporally_dead_accessor.name}'"
+        )
         self.suspended_symbols.add(name.id)
-        self.suspended_resolves.setdefault(top_level_dead.name, {}).setdefault(
-            name.id, []
-        ).append(tdz)
-        return tdz
+        self.suspended_resolves.setdefault(
+            temporally_dead_accessor.name, {}
+        ).setdefault(name.id, set()).add(suspended)
+        debug_verbose_print(f"  Current suspended_resolves: {self.suspended_resolves}")
+        return suspended
 
     def suspendable_scope(
         self,
@@ -660,19 +679,23 @@ class SymbolScopeVisitor(TyphonASTVisitor):
         return self.add_suspended_resolve(name, belong_top_level_scope, is_mutation)
 
     # Access to maybe temporally dead variable. return False if access is not valid.
-    # Copy the dependency of suspended access as current scope's dependency.
-    def access_temporal_dead(self, name: ast.Name) -> bool:
-        tdz_depends = self.suspended_resolves.get(name.id, None)
-        if tdz_depends is None:
+    # When temporally dead, copy transitively the dependency of suspended access
+    # (if exists) as current scope's dependency.
+    def access_maybe_temporal_dead(self, name: ast.Name) -> bool:
+        name_depends_but_unresolved = self.suspended_resolves.get(name.id, None)
+        if name_depends_but_unresolved is None:
             return True  # Not dead
         belong_top_level_scope = self.suspendable_scope()
         if belong_top_level_scope is None:
             return False  # Invalid access
-        # Copy the dependency to current scope
-        for _, suspends in tdz_depends.items():
-            for tdz in suspends:
+        # Copy the dependencies (not resolved yet) of name to current scope
+        for _, suspended_accesses in name_depends_but_unresolved.items():
+            debug_verbose_print(
+                f" Copying suspended accesses for '{name.id}': suspends={suspended_accesses}"
+            )
+            for suspended in suspended_accesses:
                 self.add_suspended_resolve(
-                    tdz.name, belong_top_level_scope, tdz.is_mutation
+                    suspended.name, belong_top_level_scope, suspended.is_mutation
                 )
         return True
 
@@ -796,12 +819,15 @@ class SymbolScopeVisitor(TyphonASTVisitor):
             if self.is_temporal_dead(node.id):
                 # Accessing to a temporally dead variable
                 debug_verbose_print(f"Temporal dead access to '{node.id}'")
-                if not self.access_temporal_dead(node):
+                if not self.access_maybe_temporal_dead(node):
+                    debug_verbose_print(f"TDZ violation to '{node.id}'")
                     return self.error_tdz_violation(node)
+            debug_verbose_print(f"Accessing variable '{node.id}'")
             self.access_to_symbol_non_decl(
                 sym, is_mutation=self.non_declaration_assign_context
             )
         with self.type_annotation_maybe_in_declaration(node):
+            debug_verbose_print(f"Maybe type annotated Name: {ast.dump(node)}")
             return self.generic_visit(node)
 
     def visit_Starred(self, node: ast.Starred):

Typhon/Transform/type_abbrev_desugar.py

@@ -12,12 +12,11 @@ from ..Grammar.typhon_ast import (
     is_typing_expression,
     is_optional_question,
 )
-from ..Grammar.syntax_errors import (
-    raise_type_annotation_error,
-    try_handle_syntax_error_or,
-)
 from .visitor import TyphonASTVisitor, TyphonASTTransformer
-from .utils.imports import add_import_for_protocol, get_insert_point_for_class
+from .utils.imports import (
+    get_insert_point_for_class,
+    get_protocol,
+)
 from ..Driver.debugging import debug_print, debug_verbose_print
 
 
@@ -34,7 +33,7 @@ class _GatherArrowType(TyphonASTVisitor):
 
 
 def _protocol_for_function_type(
-    func_type: FunctionType, arrow_type_name: str, protocol_name: str
+    mod: ast.Module, func_type: FunctionType, arrow_type_name: str
 ) -> ast.ClassDef:
     func_type.id = arrow_type_name
     args = get_args_of_function_type(func_type)
@@ -77,9 +76,7 @@ def _protocol_for_function_type(
     )
     protocol_def = ast.ClassDef(
         name=arrow_type_name,
-        bases=[
-            ast.Name(id=protocol_name, ctx=ast.Load()),
-        ],
+        bases=[get_protocol(mod, ctx=ast.Load(), **get_empty_pos_attributes())],
         keywords=[],
         body=[func_def],
         decorator_list=[],
@@ -92,18 +89,18 @@ def _protocol_for_function_type(
 
 
 def _add_protocols(
-    mod: ast.Module, func_types: list[tuple[FunctionType, str]], protocol_name: str
+    mod: ast.Module, func_types: list[tuple[FunctionType, str]]
 ) -> dict[FunctionType, ast.ClassDef]:
     result: dict[FunctionType, ast.ClassDef] = {}
+    # Ensure protocol is imported before classes.
+    get_protocol(mod, ctx=ast.Load(), **get_empty_pos_attributes())
     # Insert after imports.
     insert_point = get_insert_point_for_class(mod)
     for func_type, arrow_type_name in func_types:
         debug_print(
             f"Adding protocol for function type: {func_type.__dict__} as {arrow_type_name}"
         )
-        protocol_def = _protocol_for_function_type(
-            func_type, arrow_type_name, protocol_name
-        )
+        protocol_def = _protocol_for_function_type(mod, func_type, arrow_type_name)
         result[func_type] = protocol_def
         mod.body.insert(insert_point, protocol_def)
         insert_point += 1
@@ -193,8 +190,7 @@ def type_abbrev_desugar(mod: ast.Module):
     gatherer = _GatherArrowType(mod)
     gatherer.run()
     if gatherer.func_types:
-        protocol_name = add_import_for_protocol(mod)
-        _add_protocols(mod, gatherer.func_types, protocol_name)
+        _add_protocols(mod, gatherer.func_types)
     # Run optional question first, as it is represented as Tuple nodes.
     _OptionalQuestionTransformer(mod).run()
     _TupleListTransformer(mod).run()

Typhon/Transform/type_annotation_check_expand.py

@@ -13,7 +13,7 @@ from ..Grammar.typhon_ast import (
 from ..Grammar.syntax_errors import (
     raise_type_annotation_error,
     handle_syntax_error,
-    TyphonSyntaxError,
+    TyphonTransformSyntaxError,
 )
 from .visitor import TyphonASTTransformer, TyphonASTVisitor, flat_append
 from ..Driver.debugging import debug_print, debug_verbose_print
@@ -50,7 +50,7 @@ def _expand_target_annotation(
             result.append(new_assign)
             copy_is_let_var(orig_node, new_assign)
         return result
-    except TyphonSyntaxError as e:
+    except TyphonTransformSyntaxError as e:
         handle_syntax_error(module, e)
         return []
 

Typhon/Transform/utils/imports.py

@@ -1,8 +1,10 @@
 from ...Grammar.typhon_ast import (
+    PosAttributes,
     add_import_alias_top,
     is_case_irrefutable,
     get_pos_attributes,
     pos_attribute_to_range,
+    set_is_internal_name,
     set_is_var,
 )
 from ..name_generator import (
@@ -14,33 +16,66 @@ from ..name_generator import (
 import ast
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Protocol, Iterable, Final
+from typing import Protocol, Iterable, Final, Unpack
 
 
-def add_import_for_protocol(mod: ast.Module):
+def _add_import_for_protocol(mod: ast.Module):
     name = get_protocol_name()
     add_import_alias_top(mod, "typing", "Protocol", name)
     return name
 
 
+def get_protocol(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    protocol_name = _add_import_for_protocol(mod)
+    return set_is_internal_name(ast.Name(id=protocol_name, ctx=ctx, **kwargs))
+
+
 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):
+def get_final(ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]) -> ast.Name:
+    final_name = get_final_name()
+    return set_is_internal_name(ast.Name(id=final_name, ctx=ctx, **kwargs))
+
+
+def add_import_get_final(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    final_name = add_import_for_final(mod)
+    return set_is_internal_name(ast.Name(id=final_name, ctx=ctx, **kwargs))
+
+
+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):
+def get_dataclass(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    dataclass_name = _add_import_for_dataclass(mod)
+    return set_is_internal_name(ast.Name(id=dataclass_name, ctx=ctx, **kwargs))
+
+
+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_runtime_checkable(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    runtime_checkable_name = _add_import_for_runtime_checkable(mod)
+    return set_is_internal_name(ast.Name(id=runtime_checkable_name, ctx=ctx, **kwargs))
+
+
 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)):