Replace runtime-type quotation with splice-into-source typechecking

Type-check LLM-generated Callables by splicing them into the Template's real
module source -- in place at the template def's position -- and running mypy on
the whole module, raising only on diagnostics inside the spliced region. This
removes the brittle quotation layer (type_to_ast, signature_to_ast, collect_*,
_RenameTransformer) and the runtime/local-type stubbing it depended on, which
mishandled common types such as Enum and runtime-created Pydantic models.

- mypy_type_check now takes (generated, anchor); the anchor (Template.__default__)
  is provided by the type_check_anchor effect op, bound per call by
  Template.__apply__ (so nested synthesis sees the right one) and rebound to None
  around tool-argument decoding, so the argument path skips the check.
- Region-scoped diagnostics: unrelated pre-existing errors elsewhere in the module
  never block synthesis (no spurious retry burn).
- Leaves the template def's decorators untouched (mypy checks the body against its
  declared return type regardless of decorators); explicit pre-scan for non-nestable
  constructs (star-import, __future__); source recovery via getsourcelines/file/
  linecache (REPL-defined templates); fatal mypy errors are surfaced not swallowed.
- Name collisions (#542) are handled structurally by nesting/shadowing, so the
  AST-rename pass is deleted.
- Delete the quotation emitters + their unit tests; add behavior tests covering
  collision shadowing, the gate, closures, method/static/class templates,
  Enum/dataclass context, injected-name, non-nestable, and linecache recovery.

Author: datvo06

effectful/handlers/llm/completions.py

@@ -30,7 +30,7 @@
     Encodable,
     to_content_blocks,
 )
-from effectful.handlers.llm.evaluation import ReplSession
+from effectful.handlers.llm.evaluation import ReplSession, type_check_anchor
 from effectful.handlers.llm.template import (
     Agent,
     Template,
@@ -430,15 +430,18 @@ def call_assistant[T](
     encoding: pydantic.TypeAdapter[DecodedToolCall] = pydantic.TypeAdapter(
         Encodable[DecodedToolCall]
     )
-    for raw_tool_call in message.get("tool_calls") or []:
-        try:
-            tool_calls += [encoding.validate_python(raw_tool_call, context=tools)]
-        except Exception as e:
-            raise ToolCallDecodingError(
-                raw_tool_call=raw_tool_call,
-                original_error=e,
-                raw_message=raw_message,
-            ) from e
+    # Tool-argument Callables have no source anchor (out of scope for the splice
+    # type check), so suppress the anchor while decoding them.
+    with handler({type_check_anchor: lambda: None}):
+        for raw_tool_call in message.get("tool_calls") or []:
+            try:
+                tool_calls += [encoding.validate_python(raw_tool_call, context=tools)]
+            except Exception as e:
+                raise ToolCallDecodingError(
+                    raw_tool_call=raw_tool_call,
+                    original_error=e,
+                    raw_message=raw_message,
+                ) from e
 
     result = None
     if not tool_calls:
@@ -672,7 +675,15 @@ def _call[**P, T](
         )  # type: ignore
         history_copy = history.copy()
 
-        with handler({_get_history: lambda: history_copy}):
+        # Bind the type-check anchor to this Template's underlying function for the
+        # duration of the call. Handler scope (not data context) means nested or
+        # recursive synthesis sees the right anchor -- innermost wins.
+        with handler(
+            {
+                _get_history: lambda: history_copy,
+                type_check_anchor: lambda: template.__default__,
+            }
+        ):
             if (
                 not _get_history()
                 or next(iter(_get_history().values()))["role"] != "system"

effectful/handlers/llm/encoding.py

@@ -551,7 +551,13 @@ def _validate(value: Any, info: pydantic.ValidationInfo) -> Callable:
             )
 
         _validate_signature_ast(last_stmt, expected_params)
-        evaluation.type_check(module, ctx, expected_params, expected_return)
+
+        # `type_check_anchor` is the Template's underlying function, bound per call
+        # by Template.__apply__; it is None for tool-argument decoding, which
+        # therefore skips the source-anchored type check.
+        anchor = evaluation.type_check_anchor()
+        if anchor is not None:
+            evaluation.type_check(module, anchor)
 
         g: MutableMapping[str, Any] = {}
         g.update(ctx)