added implicit receivers

emit one positional-only marker for a receiver callable

any `/` the arguments emit — explicit, or implied by a bare positional
followed by a named parameter — already closes off the receiver, so the
protocol form was rendering two and producing invalid python

fix implicit receiver review findings

- a scope that binds the name shadows an outer receiver callable, as it
  would shadow an ordinary load; `x.fn()` no longer resolves past a local
  binding and silently lowers to a call of it
- reject a trailing lambda block that rebinds `it` and uses its receiver's
  members: the lowering reads them from `it`
- guard the receiver-callable parse arm with the recursion limit its
  sibling arms use
- widen the synthesized protocol receiver parameter name past any
  parameter the callable declares itself
- name the receiver in a missing-argument diagnostic

render and traverse the implicit receiver everywhere

codegen dropped the receiver when unparsing a callable type, and
`any_over_expr` never visited it. adds formatter, parser and codegen
round-trip coverage for the surface syntax

Author: KotlinIsland

crates/by_transforms/src/transforms/ast_driver.rs

@@ -37,13 +37,13 @@ use super::{
     annotation, anon_named_tuple, auto_quote, callable, character_type, checked_cast, coalesce,
     coalesce_chain, compat, context_params, decl_site_variance, decorator_keyword, dedent_string,
     dynamic_keyword, empty_declarations, extension, float_const, force_unwrap, frameworks,
-    generic_call, generics, grapheme_string, identity_swap, implicit_typing, inferred_annotation,
-    init_method, just_float, kw_subscript, literal_types, local_once, main_function, modifiers,
-    mutable_defaults, none_chain, optional_type, overload, parametric_is, postfix_await, propagate,
-    properties, protocol_type, reified_generic, repeated_underscore, sentinel, some_ctor,
-    soundness, string_tag, super_keyword, symbolic_type_op, top_star, trailing_lambda, tuple_index,
-    type_is, type_reification, typed_dict_literal, typed_lambda, typeof_keyword, unpack,
-    use_site_variance,
+    generic_call, generics, grapheme_string, identity_swap, implicit_receiver, implicit_typing,
+    inferred_annotation, init_method, just_float, kw_subscript, literal_types, local_once,
+    main_function, modifiers, mutable_defaults, none_chain, optional_type, overload, parametric_is,
+    postfix_await, propagate, properties, protocol_type, reified_generic, repeated_underscore,
+    sentinel, some_ctor, soundness, string_tag, super_keyword, symbolic_type_op, top_star,
+    trailing_lambda, tuple_index, type_is, type_reification, typed_dict_literal, typed_lambda,
+    typeof_keyword, unpack, use_site_variance,
 };
 use crate::Config;
 use crate::type_info::TypeInfo;
@@ -490,6 +490,7 @@ pub(crate) fn run_against_source<'a>(
     let context_params_pass = context_params::ContextParamsPass::new(source_ref);
     let extension_block_pass = extension::ExtensionBlockPass::new(source_ref);
     let extension_call_pass = extension::ExtensionCallPass;
+    let implicit_receiver_pass = implicit_receiver::ImplicitReceiverPass;
     let frameworks_pass = frameworks::FrameworksPass::new(source_ref);
     let variance_pass = decl_site_variance::VarianceStripPass::new(source_ref);
     let anon_named_tuple_pass =
@@ -594,6 +595,11 @@ pub(crate) fn run_against_source<'a>(
         // type-directed rewrite of attribute accesses ty resolved to
         // extension members (`xs.second()` → `__by_ext__list__second(xs)`)
         &extension_call_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
+        &implicit_receiver_pass,
         &dynamic_keyword_pass,
         // import-only companion to the ty-side implicit `Character` resolution;
         // emits no text edits, so ordering among the type passes is free

crates/by_transforms/src/transforms/callable.rs

@@ -311,12 +311,17 @@ impl<'src> CallableSyntax<'src> {
     /// `args` / `slash` / `star` are passed separately rather than read off a
     /// node so a protocol method member can hand over the parameters that
     /// follow its receiver, which is a name rather than a type.
+    ///
+    /// `implicit_receiver` is the rendered leading parameter of a basedpython
+    /// implicit receiver (`int.() -> str`), which is a type rather than a name and
+    /// so is spelled by a synthesized parameter.
     pub(crate) fn render_protocol_params(
         &mut self,
         args: &[Expr],
         explicit_slash: Option<usize>,
         star: Option<usize>,
         receiver: &str,
+        implicit_receiver: Option<String>,
     ) -> String {
         let mut parts: Vec<String> = vec![receiver.to_owned()];
         // implicit `/` after the last bare positional (no label) when followed
@@ -339,6 +344,15 @@ impl<'src> CallableSyntax<'src> {
             })
         };
         let slash = explicit_slash.or(implicit_slash);
+        // an implicit receiver leads the parameter list, positional-only. any `/`
+        // the arguments themselves emit comes after the receiver and so already
+        // closes it off — a second one is a `SyntaxError`
+        if let Some(implicit_receiver) = implicit_receiver {
+            parts.push(implicit_receiver);
+            if slash.is_none() {
+                parts.push("/".to_owned());
+            }
+        }
         let mut star_emitted = false;
         for (i, arg) in args.iter().enumerate() {
             if Some(i) == slash {
@@ -485,27 +499,40 @@ impl<'src> CallableSyntax<'src> {
                 let (prefix, paramspec) = self.paramspec_tail(ct)?;
                 let ret_str = self.rewrite_or_leaf(&ct.returns);
                 let ps = self.rewrite_or_leaf(paramspec);
-                if prefix.is_empty() {
+                // an implicit receiver is the callable's leading positional
+                // parameter, so it joins the `Concatenate` prefix
+                let mut prefix_str: Vec<String> = ct
+                    .receiver
+                    .iter()
+                    .map(|receiver| self.rewrite_or_leaf(receiver))
+                    .collect();
+                prefix_str.extend(prefix.iter().map(|a| self.rewrite_or_leaf(a)));
+                if prefix_str.is_empty() {
                     Some(format!("Callable[{ps}, {ret_str}]"))
                 } else {
                     self.needs_concatenate_import = true;
-                    let prefix_str = prefix
-                        .iter()
-                        .map(|a| self.rewrite_or_leaf(a))
-                        .collect::<Vec<_>>()
-                        .join(", ");
                     Some(format!(
-                        "Callable[Concatenate[{prefix_str}, {ps}], {ret_str}]"
+                        "Callable[Concatenate[{}, {ps}], {ret_str}]",
+                        prefix_str.join(", ")
                     ))
                 }
             }
             Expr::CallableType(ct) if self.is_non_denotable(ct) => {
                 self.needs_protocol_import = true;
+                let implicit_receiver = ct.receiver.as_ref().map(|receiver| {
+                    let rendered = self.rewrite_or_leaf(receiver);
+                    format!(
+                        "{}: {}",
+                        receiver_parameter_name(ct),
+                        quote_forward_ref(&rendered)
+                    )
+                });
                 let params = self.render_protocol_params(
                     &ct.args,
                     ct.parameter_slash.map(|i| i as usize),
                     ct.parameter_star.map(|i| i as usize),
                     "self",
+                    implicit_receiver,
                 );
                 let returns = quote_forward_ref(&self.rewrite_or_leaf(&ct.returns));
                 let shape = ProtocolShape { params, returns };
@@ -514,6 +541,9 @@ impl<'src> CallableSyntax<'src> {
             // `(...) -> R` — a single bare ellipsis parameter list is python's
             // "any arguments" callable: `Callable[..., R]`, not the
             // single-`...`-argument `Callable[[...], R]`
+            // a receiver in front of a gradual parameter list is absorbed by it:
+            // `Callable[..., R]` already accepts the receiver-first call, and
+            // `Concatenate[T, ...]` is not spellable on every supported version
             Expr::CallableType(ExprCallableType { args, returns, .. })
                 if matches!(args.as_slice(), [Expr::EllipsisLiteral(_)]) =>
             {
@@ -522,13 +552,19 @@ impl<'src> CallableSyntax<'src> {
                 Some(format!("Callable[..., {ret_str}]"))
             }
 
-            Expr::CallableType(ExprCallableType { args, returns, .. }) => {
+            Expr::CallableType(ExprCallableType {
+                receiver,
+                args,
+                returns,
+                ..
+            }) => {
                 self.needs_import = true;
-                let args_str = args
+                let mut rendered: Vec<String> = receiver
                     .iter()
-                    .map(|a| self.rewrite_or_leaf(a))
-                    .collect::<Vec<_>>()
-                    .join(", ");
+                    .map(|receiver| self.rewrite_or_leaf(receiver))
+                    .collect();
+                rendered.extend(args.iter().map(|a| self.rewrite_or_leaf(a)));
+                let args_str = rendered.join(", ");
                 let ret_str = self.rewrite_or_leaf(returns);
                 Some(format!("Callable[[{args_str}], {ret_str}]"))
             }
@@ -691,6 +727,37 @@ fn quote_forward_ref(ty: &str) -> String {
     format!("\"{}\"", ty.replace('\\', "\\\\").replace('"', "\\\""))
 }
 
+/// The synthesized name of a receiver parameter in a protocol `__call__`. The
+/// receiver is unnamed in the surface syntax, so any name works — but a callable
+/// may itself declare a parameter called `_receiver`, and two parameters of the
+/// same name is a `SyntaxError` in the emitted class rather than a parse error
+/// the final verification would catch. Widen until it is free.
+fn receiver_parameter_name(ct: &ExprCallableType) -> String {
+    let mut name = "_receiver".to_owned();
+    while declared_parameter_names(ct).any(|declared| declared == name) {
+        name.push('_');
+    }
+    name
+}
+
+/// The parameter names a callable's arguments spell, in any of the named forms
+/// (`name: T`, `*args: T`, `**kwargs: T`)
+fn declared_parameter_names(ct: &ExprCallableType) -> impl Iterator<Item = &str> {
+    ct.args.iter().filter_map(|arg| {
+        let Expr::Named(named) = arg else {
+            return None;
+        };
+        let target = match named.target.as_ref() {
+            Expr::Starred(starred) => match starred.value.as_ref() {
+                Expr::Starred(inner) => inner.value.as_ref(),
+                value => value,
+            },
+            target => target,
+        };
+        target.as_name_expr().map(|name| name.id.as_str())
+    })
+}
+
 /// whether `expr` is a `Name` / `Attribute` referring to the given identifier
 fn is_named(expr: &Expr, ident: &str) -> bool {
     match expr {

crates/by_transforms/src/transforms/extension.rs

@@ -388,7 +388,7 @@ pub(crate) fn hoist_backing_functions(
 /// does the postfix spine of `expr` contain an optional (`?.`) segment? the
 /// receiver of an extension rewrite must not, because the rewrite hoists the
 /// member access out of the chain's short-circuit
-fn spine_has_optional(expr: &Expr) -> bool {
+pub(super) fn spine_has_optional(expr: &Expr) -> bool {
     match expr {
         Expr::Attribute(attr) => attr.optional || spine_has_optional(&attr.value),
         Expr::Subscript(subscript) => spine_has_optional(&subscript.value),
@@ -399,7 +399,7 @@ fn spine_has_optional(expr: &Expr) -> bool {
 
 /// the source span of a call's arguments (positional and keyword), without
 /// the parentheses. `None` when the call has no arguments
-fn arguments_span(arguments: &ast::Arguments) -> Option<TextRange> {
+pub(super) fn arguments_span(arguments: &ast::Arguments) -> Option<TextRange> {
     let starts = arguments
         .args
         .iter()

crates/by_transforms/src/transforms/generics.rs

@@ -904,6 +904,9 @@ fn rename_in_expr(expr: &Expr, renames: &HashMap<String, String>, edits: &mut Ve
         // an arrow callable `(**P) -> None` lowers to `Callable[P, None]` via a template edit
         // that passes its operand source through, so a rename on the inner name still lands
         Expr::CallableType(c) => {
+            if let Some(receiver) = &c.receiver {
+                rename_in_expr(receiver, renames, edits);
+            }
             c.args
                 .iter()
                 .for_each(|a| rename_in_expr(a, renames, edits));