Summary

Added support for calling ref self methods on temporary expressions, allowing code like make_counter().increment() where increment takes ref self. This enables method chaining on temporary values that modify self.

Type of change

Please check one:

• Bug fix (fixes incorrect behavior)
• New feature
• Performance improvement
• Documentation change with concrete technical impact
• Style, wording, formatting, or typo-only change

Why is this change needed?

Previously, methods that take ref self could only be called on variables, not on temporary expressions. This limitation prevented method chaining for methods that modify self, requiring users to create intermediate variables. This change allows for more fluent API design where methods can modify state and return self for chaining.

What was the behavior or documentation before?

Code like make_counter().increment() would fail to compile if increment took ref self, with an error message indicating that ref arguments must be variables. This forced developers to use intermediate variables even for simple method chains.

What is the behavior or documentation after?

Methods that take ref self can now be called on temporary expressions, enabling patterns like:

make_counter().increment().increment()

This works by introducing a new TempReference variant for function call arguments that handles passing temporary expressions by reference.

Additional context

The implementation:

1. Adds a new TempReference variant to ExprFunctionCallArg
2. Restructures NamedArg to track when temporary references are allowed
3. Updates the lowering pass to handle the new argument type
4. Adds test cases to verify the functionality

This change only applies to ref self parameters in method calls, not to regular ref parameters in function calls, which still require variables.