fix: schema lambda calling

Signed-off-by: Peefy <xpf6677@163.com>

Author: Peefy

crates/evaluator/src/context.rs

@@ -74,6 +74,77 @@ impl<'ctx> Evaluator<'ctx> {
             .push(LambdaOrSchemaEvalContext::Lambda(lambda_ctx));
     }
 
+    /// Push a lambda definition scope into the lambda stack with an optional receiver
+    #[inline]
+    pub fn push_lambda_with_receiver(
+        &self,
+        lambda_ctx: FunctionEvalContextRef,
+        current_pkgpath: &str,
+        frame_pkgpath: &str,
+        level: usize,
+        receiver: Option<&kcl_runtime::ValueRef>,
+    ) {
+        // Capture function schema this reference.
+        // Use the provided receiver if available, otherwise use captured this
+        if let Some(recv) = receiver {
+            if recv.is_schema() || recv.is_dict() {
+                // For schema/dict method calls, use the captured this as a template
+                // but update its value with the receiver
+                if let Some(this_ctx) = &lambda_ctx.this {
+                    // Create a new schema context using the captured context as template,
+                    // but with the receiver's value and config
+                    let updated_ctx = match &this_ctx.ctx {
+                        EvalContext::Schema(schema_ctx) => {
+                            let config = if recv.is_schema() {
+                                // For schemas, config is the same as value
+                                recv.clone()
+                            } else {
+                                // For dicts, use the dict itself as config
+                                recv.clone()
+                            };
+                            let new_ctx = schema_ctx.borrow().new_with_value(recv, &config);
+                            EvalContext::Schema(new_ctx)
+                        }
+                        EvalContext::Rule(_) => {
+                            // Should not happen for schema methods
+                            this_ctx.eval_ctx()
+                        }
+                    };
+                    self.push_schema(updated_ctx);
+                } else {
+                    // No captured this, but receiver is schema/dict
+                    // Try to find a schema context from the stack to use as template
+                    if let Some(ctx) = self.schema_stack.borrow().last() {
+                        if let EvalContext::Schema(schema_ctx) = ctx {
+                            let config = if recv.is_schema() {
+                                recv.clone()
+                            } else {
+                                recv.clone()
+                            };
+                            let new_ctx = schema_ctx.borrow().new_with_value(recv, &config);
+                            self.push_schema(EvalContext::Schema(new_ctx));
+                        }
+                    }
+                }
+            } else if let Some(this) = &lambda_ctx.this {
+                self.push_schema(this.eval_ctx());
+            }
+        } else if let Some(this) = &lambda_ctx.this {
+            self.push_schema(this.eval_ctx());
+        }
+
+        // Inner scope function calling.
+        // Note the minimum lambda.ctx.level is 2 for the top level lambda definitions.
+        if frame_pkgpath == current_pkgpath && level >= lambda_ctx.level {
+            // The scope cover is [lambda.ctx.level, self.scope_level()]
+            self.push_scope_cover(lambda_ctx.level, level);
+        }
+        self.lambda_stack.borrow_mut().push(lambda_ctx.clone());
+        self.ctx_stack
+            .borrow_mut()
+            .push(LambdaOrSchemaEvalContext::Lambda(lambda_ctx));
+    }
+
     /// Pop a lambda definition scope.
     #[inline]
     pub fn pop_lambda(

crates/evaluator/src/func.rs

@@ -90,6 +90,20 @@ impl<'ctx> Evaluator<'ctx> {
         args: &ValueRef,
         kwargs: &ValueRef,
     ) -> ValueRef {
+        self.invoke_proxy_function_with_receiver(proxy_index, args, kwargs, None)
+    }
+
+    #[inline]
+    pub(crate) fn invoke_proxy_function_with_receiver(
+        &'ctx self,
+        proxy_index: Index,
+        args: &ValueRef,
+        kwargs: &ValueRef,
+        receiver: Option<&ValueRef>,
+    ) -> ValueRef {
+        // Capture the current_method_receiver before it might be overwritten by arg evaluation
+        let stored_receiver = self.current_method_receiver.borrow().clone();
+
         let frame = {
             let frames = self.frames.borrow();
             frames
@@ -114,9 +128,23 @@ impl<'ctx> Evaluator<'ctx> {
                 // Push the current lambda scope level in the lambda stack.
                 let pkgpath = self.current_pkgpath();
                 let level = self.scope_level();
-                self.push_lambda(lambda.ctx.clone(), &pkgpath, &frame.pkgpath, level);
+
+                // Use the stored receiver we captured earlier
+                let effective_receiver = receiver.or(stored_receiver.as_ref());
+
+                self.push_lambda_with_receiver(
+                    lambda.ctx.clone(),
+                    &pkgpath,
+                    &frame.pkgpath,
+                    level,
+                    effective_receiver,
+                );
                 let value = (lambda.body)(self, &lambda.ctx, args, kwargs);
                 self.pop_lambda(lambda.ctx.clone(), &pkgpath, &frame.pkgpath, level);
+
+                // Clear the stored receiver after lambda execution completes
+                *self.current_method_receiver.borrow_mut() = None;
+
                 value
             }
             // Call a schema and return the schema value.

crates/evaluator/src/lib.rs

@@ -91,6 +91,8 @@ pub struct Evaluator<'ctx> {
     pub backtrack_meta: RefCell<Vec<BacktrackMeta>>,
     /// Current AST id for the evaluator walker.
     pub ast_id: RefCell<AstIndex>,
+    /// Current method receiver for schema method calls (e.g., b2 in b2.add())
+    pub current_method_receiver: RefCell<Option<kcl_runtime::ValueRef>>,
 }
 
 #[derive(Clone)]
@@ -156,6 +158,7 @@ impl<'ctx> Evaluator<'ctx> {
             backtrack_meta: RefCell::new(Default::default()),
             ast_id: RefCell::new(AstIndex::default()),
             ctx_stack: RefCell::new(Default::default()),
+            current_method_receiver: RefCell::new(None),
         }
     }
 

crates/evaluator/src/node.rs

@@ -954,6 +954,8 @@ impl<'ctx> TypedResultWalker<'ctx> for Evaluator<'ctx> {
     fn walk_lambda_expr(&self, lambda_expr: &'ctx ast::LambdaExpr) -> Self::Result {
         let func = Arc::new(func_body);
         // Capture schema self
+        let closure_map = self.get_current_closure_map();
+
         let proxy = FunctionCaller::new(
             FunctionEvalContext {
                 node: lambda_expr.clone(),
@@ -966,7 +968,7 @@ impl<'ctx> TypedResultWalker<'ctx> for Evaluator<'ctx> {
                         value: ctx.value(),
                         config: ctx.config(),
                     }),
-                closure: self.get_current_closure_map(),
+                closure: closure_map,
                 level: self.scope_level() + 1,
             },
             func,
@@ -1478,7 +1480,7 @@ impl<'ctx> Evaluator<'ctx> {
             // Positional arguments
             let is_in_range = i < argument_len;
             if is_in_range {
-                let mut arg_value = match args.list_get_option(i as isize) {
+                let mut arg_value = match args.list_get(i as isize) {
                     Some(v) => v,
                     None => self.undefined_value(),
                 };
@@ -1489,7 +1491,10 @@ impl<'ctx> Evaluator<'ctx> {
                 // Mark positional argument as a local variable
                 let name = arg_name.names[0].node.as_str();
                 self.add_local_var(name);
-                self.store_variable(&arg_name.names[0].node, arg_value);
+                // FIX: Use add_variable instead of store_variable for positional arguments
+                // store_variable only updates existing variables, but positional parameters
+                // don't exist yet, so we need to use add_variable to create them
+                self.add_variable(name, arg_value);
             } else {
                 break;
             }

crates/evaluator/src/scope.rs

@@ -214,8 +214,7 @@ impl<'ctx> Evaluator<'ctx> {
         let msg = format!("pkgpath {} is not found", current_pkgpath);
         let scopes = pkg_scopes.get_mut(&current_pkgpath).expect(&msg);
         if let Some(last) = scopes.last_mut() {
-            let variables = &mut last.variables;
-            variables.insert(name.to_string(), pointer);
+            last.variables.insert(name.to_string(), pointer);
         }
     }
 
@@ -349,7 +348,9 @@ impl<'ctx> Evaluator<'ctx> {
     /// Get the variable value named `name` from the scope, return Err when not found
     pub fn get_variable(&self, name: &str) -> ValueRef {
         let current_pkgpath = self.current_pkgpath();
-        self.get_variable_in_pkgpath(name, &current_pkgpath)
+        // Use a more obvious debug marker
+        let result = self.get_variable_in_pkgpath(name, &current_pkgpath);
+        result
     }
 
     /// Get the variable value named `name` from the scope, return Err when not found
@@ -519,10 +520,28 @@ impl<'ctx> Evaluator<'ctx> {
                     } else {
                         false
                     };
-                    if index >= last_lambda_scope && !ignore {
-                        var.clone()
+                    // Determine if we should use the current scope value or closure value
+                    // The logic differs for schema methods vs regular lambdas:
+                    // - Schema methods: lambda level may be > execution level, need special handling
+                    // - Regular lambdas: use original logic
+                    let is_schema_method = self.current_method_receiver.borrow().is_some();
+                    if is_schema_method {
+                        // Schema method: prefer current value if variable is in current scope
+                        // (even if it's also in the closure from previous execution)
+                        if index >= INNER_LEVEL && !ignore {
+                            // Variable is in current execution scope, use current value
+                            var.clone()
+                        } else {
+                            // Variable from outer scope or builtin/global, check closure
+                            lambda_ctx.closure.get(name).unwrap_or(var).clone()
+                        }
                     } else {
-                        lambda_ctx.closure.get(name).unwrap_or(var).clone()
+                        // Regular lambda: use original logic
+                        if index >= last_lambda_scope && !ignore {
+                            var.clone()
+                        } else {
+                            lambda_ctx.closure.get(name).unwrap_or(var).clone()
+                        }
                     }
                 } else {
                     // Not in the lambda, maybe a local variable.
@@ -547,7 +566,9 @@ impl<'ctx> Evaluator<'ctx> {
             .as_ref()
             .map(|ctx| ctx.closure.clone())
             .unwrap_or_default();
-        // Get variable map including schema  in the current scope.
+
+        // Capture all variables from scopes >= INNER_LEVEL
+        // This is the original simple logic that works correctly for nested lambdas
         for i in INNER_LEVEL..scopes.len() {
             let variables = &scopes
                 .get(i)
@@ -574,12 +595,26 @@ impl<'ctx> Evaluator<'ctx> {
             } else {
                 self.undefined_value()
             };
+            // Track the receiver for schema method calls
+            let mut receiver = value.clone();
             for i in 0..names.len() - 1 {
                 let attr = names[i + 1];
                 if i == 0 && !pkgpath.is_empty() {
                     value = self.get_variable_in_pkgpath(attr, pkgpath);
+                    receiver = value.clone();
                 } else {
-                    value = value.load_attr(attr)
+                    value = value.load_attr(attr);
+                    // Fix: If we're loading a lambda method from a schema instance,
+                    // store the receiver so it can be used when the lambda is called
+                    if true {
+                        // Check if this is a schema/dict method call
+                        if (receiver.is_schema() || receiver.is_dict()) && value.is_func() {
+                            if let Some(_proxy) = value.try_get_proxy() {
+                                // Store the receiver for use when the lambda is called
+                                *self.current_method_receiver.borrow_mut() = Some(receiver.clone());
+                            }
+                        }
+                    }
                 }
             }
             value
@@ -614,11 +649,8 @@ impl<'ctx> Evaluator<'ctx> {
 
     /// Load global or local value from name.
     pub fn load_name(&self, name: &str) -> ValueRef {
-        match (
-            self.is_in_schema(),
-            self.is_in_lambda(),
-            self.is_local_var(name),
-        ) {
+        let is_local = self.is_local_var(name);
+        let result = match (self.is_in_schema(), self.is_in_lambda(), is_local) {
             // Get variable from the global lazy scope.
             (false, _, false) => {
                 let variable = self.get_variable(name);
@@ -689,7 +721,9 @@ impl<'ctx> Evaluator<'ctx> {
                     _ => self.get_variable_in_schema_or_rule(name),
                 }
             }
-        }
+        };
+
+        result
     }
 
     /// Load assignment target value.

tests/grammar/lambda/lambda_in_schema_method_call/main.k

@@ -0,0 +1,18 @@
+# Test for lambda functions in schema methods to ensure correct parameter passing
+# when called multiple times on different instances
+
+schema Builder:
+    """A builder schema with a lambda method that adds items"""
+    items: [str] = []
+
+    add: (str) -> Builder = lambda item: str {
+        """Add an item to the builder and return a new builder"""
+        new_items = items + [item]
+        Builder{items = new_items}
+    }
+
+# Test: Chain multiple calls
+b1 = Builder{}
+b2 = b1.add("first")
+b3 = b2.add("second")
+b4 = b3.add("third")

tests/grammar/lambda/lambda_in_schema_method_call/stdout.golden

@@ -0,0 +1,12 @@
+b1:
+  items: []
+b2:
+  items:
+  - first
+b3:
+  items:
+  - first
+b4:
+  items:
+  - first
+  - second

tests/grammar/lambda/lambda_schema_attr_access/main.k

@@ -0,0 +1,35 @@
+# Test lambda accessing schema attributes
+# This tests the fix for the bug where lambda parameters were incorrectly
+# captured from closure instead of using the current value
+
+schema Processor:
+    name: str = "default"
+    data: [str] = []
+
+    process: (str) -> Processor = lambda item: str {
+        # Lambda should access the current schema's name and data
+        new_data = data + [item]
+        Processor{name: name, data: new_data}
+    }
+
+    processWithPrefix: (str) -> Processor = lambda item: str {
+        # Lambda should access the current schema's name
+        prefixed = "{name}:{item}"
+        new_data = data + [prefixed]
+        Processor{name: name, data: new_data}
+    }
+
+# Test 1: Default processor
+p1 = Processor{}
+p2 = p1.process("item1")
+p3 = p2.process("item2")
+
+# Test 2: Named processor
+n1 = Processor{name: "my_processor"}
+n2 = n1.process("first")
+n3 = n2.process("second")
+
+# Test 3: Process with prefix
+x1 = Processor{name: "test", data: []}
+x2 = x1.processWithPrefix("a")
+x3 = x2.processWithPrefix("b")

tests/grammar/lambda/lambda_schema_attr_access/stdout.golden

@@ -0,0 +1,33 @@
+p1:
+  name: default
+  data: []
+p2:
+  name: default
+  data:
+  - item1
+p3:
+  name: default
+  data:
+  - item1
+n1:
+  name: my_processor
+  data: []
+n2:
+  name: my_processor
+  data:
+  - first
+n3:
+  name: my_processor
+  data:
+  - first
+x1:
+  name: test
+  data: []
+x2:
+  name: test
+  data:
+  - '{name}:{item}'
+x3:
+  name: test
+  data:
+  - '{name}:{item}'