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

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/placeholder_to_function.py

@@ -93,7 +93,6 @@ class _Transform(TyphonASTTransformer):
         return lambda_expr
 
     def visit(self, node: ast.AST):
-        debug_print(f"placeholder_to_function _transform visit: {ast.dump(node)}")
         # Transform the expression transformed into function.
         if isinstance(node, ast.expr):
             if node in self.bound_exprs_to_placeholders:

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,
@@ -42,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))
@@ -67,10 +80,13 @@ 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()
+        self.anonymous_names: dict[int, str] = {}
 
     def _enter_scope(self):
         self.scopes.append({})
@@ -172,14 +188,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 +467,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 +501,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 +514,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
@@ -591,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,
@@ -628,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
 
@@ -696,9 +751,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 +781,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
                 ),
             )
@@ -742,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):