Fixes

crates/by_build/src/lib.rs

@@ -390,9 +390,10 @@ fn finish(
         anyhow::anyhow!("the `{pass}` pass produced ill-formed IR:\n  {detail}")
     })?;
 
-    // the default config on purpose, except for the target version: the
-    // lazy-import pass is what binds `JustFloat = float` locally instead of
-    // emitting a `from ty_extensions import ...` that has no module behind it.
+    // the default config on purpose, except for the target version and the
+    // deferral of `from` imports: the lazy-import pass is what binds
+    // `JustFloat = float` locally instead of emitting a
+    // `from ty_extensions import ...` that has no module behind it
     //
     // the version has to be the *interpreter's*, because this python runs inside
     // the extension at import time — emitting syntax the interpreter cannot parse
@@ -402,6 +403,9 @@ fn finish(
         source.to_string()
     } else {
         let mut config = options.fallback.clone().unwrap_or_default();
+        // the compiled functions read the module's globals by name, and a deferred
+        // `from` import is in them only once something has read it
+        config.defer_from_imports = false;
         if let Some((major, minor)) = toolchain.and_then(|toolchain| toolchain.version)
             && let Ok(parsed) = format!("{major}.{minor}").parse()
         {

crates/by_build/tests/differential.rs

@@ -11561,6 +11561,24 @@ fn a_float_module_imports_without_any_extra_runtime_module() {
     assert_eq!(out, "12.0");
 }
 
+#[test]
+fn a_compiled_function_reads_a_name_its_module_imports_with_from() {
+    // below 3.15 the lazy-import polyfill defers a `from` import by binding nothing where
+    // it is written, and a compiled function reads the module's globals by name. so the
+    // fallback a compiled module embeds keeps its `from` imports ordinary ones
+    agree(
+        "fromglobal",
+        "\
+from json import dumps
+from os.path import basename as base
+
+def f(a: int) -> str:
+    return dumps([a]) + base('/x/y')
+",
+        &["m.f(1)"],
+    );
+}
+
 #[test]
 fn a_compiled_function_is_a_c_function_object() {
     // one of the few places the two builds are *meant* to differ: a natively
@@ -22840,10 +22858,64 @@ def widened(value: object) -> str:
             // the class reports the module it was written in, not `builtins`
             "(m.Node.__module__, m.Keyed.__module__)",
             "(m.Node.__name__, m.Node.__qualname__)",
-            // an imported base reaches this module as a lazy proxy, so `__mro_entries__`
-            // is what turns it into the class — and python records what was written
-            "repr(m.Node.__orig_bases__)",
+            // an imported base is the class itself, with no `__mro_entries__` to
+            // record what was written in its place
+            "'__orig_bases__' in vars(m.Node)",
+        ],
+    );
+}
+
+#[test]
+fn a_class_on_a_base_that_stands_for_others_agrees() {
+    // a base that is not a class may stand for a tuple of them through `__mro_entries__`,
+    // which python resolves before it works out a metaclass, recording what was written in
+    // `__orig_bases__`. the checker is shown the class the stand-in stands for, so the class
+    // compiles, and the metaclass here is `ABCMeta`, so the type is built by calling it
+    let Some(compiled) = agree_in(
+        "mroentries",
+        "\
+from abc import ABC
+from typing import TYPE_CHECKING
+
+
+class StandIn:
+    def __mro_entries__(self, bases: tuple[object, ...]) -> tuple[type, ...]:
+        return (ABC,)
+
+
+if TYPE_CHECKING:
+    Base = ABC
+else:
+    Base = StandIn()
+
+
+class Node(Base):
+    def kind(self) -> str:
+        return \"node\"
+",
+        &[
+            "m.Node().kind()",
+            "[base.__name__ for base in m.Node.__mro__]",
+            "type(m.Node.__orig_bases__[0]).__name__",
+            "(type(m.Node).__name__, issubclass(m.Node, __import__('abc').ABC))",
         ],
+        false,
+        by_irbuild::Language::BasedPython,
+    ) else {
+        return;
+    };
+    // and the class is the one module init built, not the interpreted definition left
+    // standing because the build gave up on it
+    let Some((python, _)) = environment() else {
+        return;
+    };
+    assert_eq!(
+        run(
+            &python,
+            &compiled,
+            "import by_diff_mroentries as m\nprint(type(m.Node.__dict__['kind']).__name__)\n",
+        ),
+        "method_descriptor"
     );
 }
 
@@ -29062,6 +29134,95 @@ class Joiner:
     );
 }
 
+/// `inspect.signature` reads a compiled function's defaults off its interpreted definition,
+/// and in `.by` a default re-evaluated per call is a marker there. a tool that binds a call
+/// from the signature and calls with `apply_defaults` hands the markers back, and the
+/// compiled boundary hands such a call to the definition, whose guard reads each one as the
+/// argument not given — the boundary was unboxing the marker as the argument instead
+#[test]
+fn a_default_marker_handed_back_agrees() {
+    const HANDED_BACK: &str = "(lambda f: (lambda b: (b.apply_defaults(), f(*b.args, **b.kwargs))[1])(__import__('inspect').signature(f).bind()))";
+    let calls = [
+        format!("[{HANDED_BACK}(m.fresh), {HANDED_BACK}(m.fresh)]"),
+        format!("[{HANDED_BACK}(m.limit), setattr(m, 'LIMIT', 5), {HANDED_BACK}(m.limit)]"),
+        format!("_warnings_from({HANDED_BACK}, m.relaxed)"),
+        format!("[{HANDED_BACK}(m.keyword), {HANDED_BACK}(m.keyword)]"),
+        "(lambda d: [m.Bag([1]).add(d), m.Bag([1]).add(d)])(__import__('inspect').signature(m.Bag.add).parameters['more'].default)".to_owned(),
+    ];
+    agree(
+        "default_markers",
+        "\
+LIMIT = 2
+
+
+def fresh(xs: list[int] = []) -> int:
+    xs.append(1)
+    return len(xs)
+
+
+def limit(x: int = LIMIT) -> int:
+    return x
+
+
+def relaxed(x: int = 1, a: int) -> int:
+    return x + a
+
+
+def keyword(*, xs: list[int] = []) -> int:
+    xs.append(1)
+    return len(xs)
+
+
+class Bag:
+    def __init__(self, items: list[int]) -> None:
+        self.items = items
+
+    def add(self, more: list[int] = [2]) -> int:
+        more.append(3)
+        return len(self.items) + len(more)
+",
+        &calls.iter().map(String::as_str).collect::<Vec<_>>(),
+    );
+}
+
+/// the marker a compiled method compares an argument against is read off its interpreted
+/// definition at module init, through `__wrapped__` where a decorator wrapped it. a
+/// `__wrapped__` that leads back round stops the walk, as `inspect.unwrap` stops, rather
+/// than holding the import forever. the decorated method itself is left to the class the
+/// interpreted definition decorated, which is the one reading its handle at init
+#[test]
+fn a_wrapped_chain_that_leads_back_round_agrees() {
+    agree_with_declines(
+        "wrapped_cycle",
+        "\
+class Looped:
+    def __init__(self, fn: (...) -> int):
+        self.fn = fn
+        self.__wrapped__ = self
+
+    def __get__(self, instance: object, owner: object = None) -> object:
+        if instance === None:
+            return self
+        return lambda xs: self.fn(instance, xs)
+
+
+def looped(fn: (...) -> int) -> Looped:
+    return Looped(fn)
+
+
+class Bag:
+    def __init__(self):
+        self.n = 1
+
+    @looped
+    def fresh(self, xs: list[int] = []) -> int:
+        xs.append(1)
+        return len(xs) + self.n
+",
+        &["[m.Bag().fresh([5]), m.Bag().fresh([5])]"],
+    );
+}
+
 #[test]
 fn the_numeric_slots_agree() {
     // every binary numeric dunder fills a `nb_*` slot, and python never looks one up by
@@ -44945,6 +45106,30 @@ def show() -> str:
     );
 }
 
+#[test]
+fn a_plain_tuple_built_as_an_anonymous_named_tuple_agrees() {
+    // the checker reads each literal as an instance of the named tuple expected where it
+    // stands, and the fields are read by name: a plain tuple the lowering built has none
+    agree_with_declines(
+        "anonbuilt",
+        "\
+def take(p: (a: int, b: int)) -> int:
+    return p.a + p.b
+
+
+def call() -> int:
+    return take((7, 8))
+
+
+def second() -> int:
+    items: list[(a: int, b: int)] = []
+    items.append((1, 2))
+    return items[0].b
+",
+        &["m.call()", "m.second()"],
+    );
+}
+
 #[test]
 fn a_checked_cast_agrees_on_the_value_it_refuses() {
     // the refusal is the point of the form, so the raise is part of the answer