@@ -640,9 +640,9 @@ pub(crate) fn run_against_source<'a>(
         &implementation_block_pass,
         &conversion_pass,
         // implicit receivers: `x.fn()` → `fn(x)` for a receiver callable in
-        // scope, and a trailing lambda block's unqualified receiver members →
-        // `it.<name>`. same shape as the extension rewrite above, which wins
-        // when both could apply
+        // scope, and a trailing lambda block's `self` / unqualified receiver
+        // members → its receiver parameter. same shape as the extension rewrite
+        // above, which wins when both could apply
         &implicit_receiver_pass,
         &dynamic_keyword_pass,
         // import-only companion to the ty-side implicit `Character` resolution;
 
@@ -9,21 +9,23 @@
 //!   in scope rather than to a member of `x`. An unapplied `x.fn` becomes a
 //!   `functools.partial`, matching how a bound method would have carried the
 //!   receiver
-//! - a bare name in a trailing lambda block that resolves to a member of the
-//!   block's receiver → `it.<name>`, where `it` is the block's implicit
-//!   parameter (the receiver itself)
+//! - a bare name in a trailing lambda block that resolves through the block's
+//!   receiver → the block's receiver parameter, either on its own (`self`) or
+//!   as the object a member is read off (`<receiver>.<name>`)
 //!
 //! Both are narrow edits nested inside the trailing-lambda template's `Src`
 //! spans, so they compose with the block lowering.
 //!
 //! [`callable`]: super::callable
 
-use ruff_python_ast::visitor::{Visitor, walk_expr, walk_stmt};
-use ruff_python_ast::{Expr, ExprAttribute, ExprContext, Stmt};
+use ruff_python_ast::visitor::{Visitor, walk_expr};
+use ruff_python_ast::{Expr, ExprAttribute, Stmt};
 use ruff_text_size::{Ranged, TextRange};
+use ty_python_semantic::ImplicitReceiverReference;
 
 use super::ast_driver::{Fragment, PassContext, TypeAwarePass};
 use super::extension::{arguments_span, spine_has_optional};
+use super::trailing_lambda::RECEIVER_PARAMETER;
 use crate::type_info::TypeInfo;
 
 struct ImplicitReceiverLower<'a> {
@@ -33,62 +35,10 @@ struct ImplicitReceiverLower<'a> {
     /// attribute ranges already rewritten as part of an enclosing call, so the
     /// bare-access arm doesn't rewrite them a second time
     handled: Vec<TextRange>,
-    /// the enclosing trailing lambda blocks, innermost last, and whether each
-    /// rebinds `it` — the name the receiver members are read from
-    blocks: Vec<Block>,
     needs_functools: bool,
 }
 
-/// An enclosing trailing lambda block, for the `it`-rebinding check
-struct Block {
-    rebinds_it: bool,
-    reported: bool,
-}
-
-/// Whether a block assigns `it` anywhere in its body. The lowering reads the
-/// receiver's members off that parameter, so a rebinding would silently redirect
-/// them to the new value. Nested scopes count too: this only decides whether to
-/// reject, and over-rejecting is the safe direction.
-fn rebinds_it(body: &[Stmt]) -> bool {
-    struct RebindsIt {
-        found: bool,
-    }
-
-    impl<'ast> Visitor<'ast> for RebindsIt {
-        fn visit_expr(&mut self, expr: &'ast Expr) {
-            if let Expr::Name(name) = expr
-                && name.id.as_str() == "it"
-                && matches!(name.ctx, ExprContext::Store | ExprContext::Del)
-            {
-                self.found = true;
-            }
-            walk_expr(self, expr);
-        }
-    }
-
-    let mut visitor = RebindsIt { found: false };
-    for stmt in body {
-        visitor.visit_stmt(stmt);
-    }
-    visitor.found
-}
-
 impl<'ast> Visitor<'ast> for ImplicitReceiverLower<'_> {
-    fn visit_stmt(&mut self, stmt: &'ast Stmt) {
-        if let Stmt::FunctionDef(function) = stmt
-            && function.is_trailing_lambda
-        {
-            self.blocks.push(Block {
-                rebinds_it: rebinds_it(&function.body),
-                reported: false,
-            });
-            walk_stmt(self, stmt);
-            self.blocks.pop();
-            return;
-        }
-        walk_stmt(self, stmt);
-    }
-
     fn visit_expr(&mut self, expr: &'ast Expr) {
         match expr {
             // `x.fn(a)` → `fn(x, a)`
@@ -127,15 +77,20 @@ impl<'ast> Visitor<'ast> for ImplicitReceiverLower<'_> {
                     }
                 }
             }
-            // a receiver member used unqualified inside a trailing lambda block
+            // the receiver of a trailing lambda block, or one of its members,
+            // used unqualified inside the block
             Expr::Name(name) => {
-                if name.ctx.is_load() && self.types.is_implicit_receiver_name(name) {
-                    if self.block_rebinds_it() {
-                        self.report_rebound_it();
-                    } else {
-                        self.edits
-                            .push((name.range(), vec![Fragment::Lit(format!("it.{}", name.id))]));
-                    }
+                if name.ctx.is_load()
+                    && let Some(reference) = self.types.implicit_receiver_name(name)
+                {
+                    let lowered = match reference {
+                        ImplicitReceiverReference::Receiver => RECEIVER_PARAMETER.to_owned(),
+                        ImplicitReceiverReference::Member => {
+                            format!("{RECEIVER_PARAMETER}.{}", name.id)
+                        }
+                    };
+                    self.edits
+                        .push((name.range(), vec![Fragment::Lit(lowered)]));
                 }
             }
             _ => {}
@@ -159,28 +114,6 @@ impl ImplicitReceiverLower<'_> {
         fragments.push(Fragment::Lit(")".to_owned()));
         self.edits.push((call.range(), fragments));
     }
-
-    /// whether the innermost enclosing block rebinds `it`, which the member
-    /// rewrite reads the receiver from
-    fn block_rebinds_it(&self) -> bool {
-        self.blocks.last().is_some_and(|block| block.rebinds_it)
-    }
-
-    /// report the rebinding once per block, however many members it uses
-    fn report_rebound_it(&mut self) {
-        let Some(block) = self.blocks.last_mut() else {
-            return;
-        };
-        if block.reported {
-            return;
-        }
-        block.reported = true;
-        self.errors.push(
-            "a trailing lambda block that rebinds `it` cannot use its receiver's members \
-             unqualified yet — the lowering reads them from `it`"
-                .to_owned(),
-        );
-    }
 }
 
 /// whether the access is a link of a `?.` chain, which the receiver rewrite
@@ -202,7 +135,6 @@ impl TypeAwarePass for ImplicitReceiverPass {
             edits: Vec::new(),
             handled: Vec::new(),
             errors: Vec::new(),
-            blocks: Vec::new(),
             needs_functools: false,
         };
         for stmt in stmts {
@@ -270,15 +202,51 @@ mod tests {
     }
 
     #[test]
-    fn trailing_block_members_bind_to_it() {
+    fn trailing_block_members_bind_to_the_receiver_parameter() {
         let out = check(indoc! {"
             def f(fn: int.() -> None) -> None:
                 fn(1)
 
             f:
                 print(imag)
         "});
-        assert!(out.contains("print(it.imag)"), "got:\n{out}");
+        assert!(out.contains("print(_by_self.imag)"), "got:\n{out}");
+        assert!(
+            out.contains("def _trailing_lambda_0(_by_self=None, it=None):"),
+            "got:\n{out}"
+        );
+    }
+
+    #[test]
+    fn a_trailing_block_spells_its_receiver_self() {
+        let out = check(indoc! {"
+            def f(fn: str.(int) -> None) -> None:
+                fn(\"a\", 1)
+
+            f:
+                print(upper(), it, self)
+        "});
+        assert!(
+            out.contains("print(_by_self.upper(), it, _by_self)"),
+            "got:\n{out}"
+        );
+    }
+
+    #[test]
+    fn an_enclosing_self_keeps_its_meaning() {
+        // the receiver is the *last* fallback, so a method's own `self` still
+        // wins — and the block's receiver parameter is a name the source cannot
+        // spell, so it cannot be shadowed either
+        let out = check(indoc! {"
+            def f(fn: str.() -> None) -> None:
+                fn(\"a\")
+
+            class C:
+                def m(self) -> None:
+                    f:
+                        print(self, upper())
+        "});
+        assert!(out.contains("print(self, _by_self.upper())"), "got:\n{out}");
     }
 
     #[test]
@@ -295,20 +263,18 @@ mod tests {
     }
 
     #[test]
-    fn rebinding_it_is_rejected() {
-        let error = transpile(
-            indoc! {"
-                def f(fn: str.() -> None) -> None:
-                    fn(\"abc\")
+    fn a_block_local_shadows_the_receiver_spelling() {
+        // a block that binds `self` itself keeps that binding — the receiver's
+        // members are read off the block's own parameter, so they are unaffected
+        let out = check(indoc! {"
+            def f(fn: str.() -> None) -> None:
+                fn(\"abc\")
 
-                f:
-                    it = 5
-                    print(upper())
-            "},
-            &Config::test_default(),
-        )
-        .expect_err("a block that rebinds `it` should be rejected");
-        assert!(error.contains("rebinds `it`"), "got:\n{error}");
+            f:
+                self = 5
+                print(self, upper())
+        "});
+        assert!(out.contains("print(self, _by_self.upper())"), "got:\n{out}");
     }
 
     #[test]
 
@@ -37,6 +37,13 @@ use super::ast_driver::{Fragment, PassContext, TypeAwarePass};
 use super::source_util::line_indent;
 use crate::type_info::{CaptureKind, TypeInfo};
 
+/// The parameter a block binds its callback's implicit receiver to. The body
+/// spells it `self`, which [`implicit_receiver`] rewrites to this name — a name
+/// the source cannot produce, so a method's own `self` is never shadowed
+///
+/// [`implicit_receiver`]: super::implicit_receiver
+pub(crate) const RECEIVER_PARAMETER: &str = "_by_self";
+
 struct TrailingLambdaLower<'a, 'src> {
     source: &'src str,
     types: &'a dyn TypeInfo,
@@ -247,9 +254,18 @@ impl TrailingLambdaLower<'_, '_> {
         // surviving bindings to pre-init before it
         let (declarations, preinits) = self.capture_declarations(function);
 
-        // `it` defaults to `None` so a callback whose type takes no argument
-        // (`() -> None`, invoked as `fn()`) can still call the block, which
-        // always declares the single implicit `it` parameter
+        // a receiver callback is called with its receiver first, so the block
+        // declares a parameter for it ahead of `it`. both default to `None` so a
+        // callback whose type takes fewer arguments (`() -> None`, invoked as
+        // `fn()`) can still call the block, which always declares them
+        let parameters = if self
+            .types
+            .trailing_lambda_callback_has_receiver(signature_callee)
+        {
+            format!("{RECEIVER_PARAMETER}=None, it=None")
+        } else {
+            "it=None".to_owned()
+        };
         let mut fragments = Vec::new();
         if !returns.is_empty() {
             fragments.push(Fragment::Lit(format!("{ret_cell} = []\n{indent}")));
@@ -259,7 +275,7 @@ impl TrailingLambdaLower<'_, '_> {
         for preinit in &preinits {
             fragments.push(Fragment::Lit(format!("{preinit} = None\n{indent}")));
         }
-        fragments.push(Fragment::Lit(format!("def {name}(it=None):")));
+        fragments.push(Fragment::Lit(format!("def {name}({parameters}):")));
         // write-through declarations so block assignments update enclosing
         // bindings; spliced ahead of the suite so they precede every use
         if let Some(declarations) = declarations {
 
@@ -8,7 +8,7 @@ use ty_python_core::{global_scope, place_table, semantic_index};
 use ty_python_semantic::types::{
     DynamicType, KnownClass, KnownInstanceType, Type, UnpackedKwargs, character,
 };
-use ty_python_semantic::{HasType, SemanticModel};
+use ty_python_semantic::{HasType, ImplicitReceiverReference, SemanticModel};
 
 /// How the postfix `^` / `!` operators test the "absent" arm of an operand's
 /// wrapped type. `T?` lowers to `T | None`, so its absent arm is `None`; a
@@ -170,9 +170,10 @@ pub(crate) trait TypeInfo {
     /// rather than a member of `x`. lowered to `fn(x)`
     fn is_implicit_receiver_attribute(&self, attribute: &ruff_python_ast::ExprAttribute) -> bool;
 
-    /// whether `name` is a member of the enclosing trailing lambda block's
-    /// receiver, used unqualified. lowered to `it.<name>`
-    fn is_implicit_receiver_name(&self, name: &ExprName) -> bool;
+    /// how `name` resolves through the enclosing trailing lambda block's
+    /// receiver: `self` is the receiver itself, any other name is a member of
+    /// it used unqualified. both lower to the block's receiver parameter
+    fn implicit_receiver_name(&self, name: &ExprName) -> Option<ImplicitReceiverReference>;
 
     /// the enum a *context-sensitively* resolved name must be qualified with —
     /// `Red` in a `Color` context lowers to `Color.Red`. `None` for every name
@@ -331,6 +332,11 @@ pub(crate) trait TypeInfo {
     /// variadic / positional-only last parameter)
     fn trailing_lambda_keyword(&self, callee: &Expr) -> Option<String>;
 
+    /// whether the trailing-lambda callee's callback declares an implicit
+    /// receiver, which the block binds as a leading parameter — the body reads
+    /// the receiver's members off it unqualified, and spells it `self`
+    fn trailing_lambda_callback_has_receiver(&self, callee: &Expr) -> bool;
+
     /// whether the trailing-lambda callee's callback parameter is `once` — the
     /// block runs exactly once, so its `return` propagates to the enclosing
     /// function rather than to the block. `false` when the marker is unreadable
@@ -546,7 +552,7 @@ impl TypeInfo for SemanticModel<'_> {
         SemanticModel::implicit_receiver_attribute(self, attribute)
     }
 
-    fn is_implicit_receiver_name(&self, name: &ExprName) -> bool {
+    fn implicit_receiver_name(&self, name: &ExprName) -> Option<ImplicitReceiverReference> {
         SemanticModel::implicit_receiver_name(self, name)
     }
 
@@ -830,6 +836,10 @@ impl TypeInfo for SemanticModel<'_> {
         SemanticModel::trailing_lambda_keyword(self, callee)
     }
 
+    fn trailing_lambda_callback_has_receiver(&self, callee: &Expr) -> bool {
+        SemanticModel::trailing_lambda_callback_has_receiver(self, callee)
+    }
+
     fn trailing_lambda_callee_is_once(&self, callee: &Expr) -> bool {
         SemanticModel::trailing_lambda_callee_is_once(self, callee)
     }
 
@@ -6,8 +6,9 @@
 //! plain function, `x.fn()` called through the receiver, an unapplied `x.fn`
 //! bound as a `functools.partial`, and a trailing lambda block using the
 //! receiver's members unqualified — and runs them on a real interpreter. A
-//! misplaced receiver argument or a member bound to the wrong object would fail
-//! here even though the type-level tests pass.
+//! misplaced receiver argument, a member bound to the wrong object, or a block
+//! whose parameters don't line up with the call would fail here even though the
+//! type-level tests pass.
 //!
 //! No third-party packages are needed, so any `python3` will do; if none is
 //! found the test skips rather than fails.
@@ -50,15 +51,16 @@ def suffixed(value: int, mark: str) -> str:
 
 assert unapplied(suffixed) == "5!", "an unapplied reference binds the receiver"
 
-# a trailing lambda block sees the receiver's members unqualified
-def apply(fn: str.() -> None) -> None:
-    fn("abc")
+# a trailing lambda block sees the receiver's members unqualified, spells the
+# receiver itself `self`, and binds the callback's own argument as `it`
+def apply(fn: str.(int) -> None) -> None:
+    fn("abc", 3)
 
 seen: str = ""
 apply:
-    seen = upper() + str(len(it))
+    seen = upper() + str(it) + self
 
-assert seen == "ABC3", "block members resolve against the receiver"
+assert seen == "ABC3abc", "a block's receiver, its members and `it` all bind"
 
 print("ok")
 "##;