How to capture by reference and avoid moves of the captured variable

[gediminasel]

In cpp1, I often create helper lambas that capture local variables by reference, e.g.

int main() {
	std::vector words = {"Alice", "Bob"};
	auto debug = [&](auto const & i) mutable -> decltype(auto) {
		return std::cout << "Hello, " << words[i] << "\n";
	};
	// Some code
	for (int i = 0; i < 2; ++i) {
		debug(i);
	}
}

I tried to do the same in cpp2:

main: () -> int = {
	words: std::vector = ( "Alice", "Bob" );
	debug := :(i) = std::cout << "Hello, (words&$*[i])$\n";
	// Some code
	for 0..<2 do (i) {
		debug(i);
	}
	// Some more code
}

But then I remembered about move-on-last-use and became scared of this code: something as simple as words2 := words; before the for loop can break this code because words would be moved.

I imagine the wrapper pattern is also affected by this move-on-last-use rule. E.g. cpp1 (full example in cpp2):

SomeObject my_object = GetMyObject(...);
CachingSomeObjectAccessor accessor(&my_object);
// Some code -- move here would break accessor
auto result = accessor->ExpensiveComputation();

So the question is what's the idiomatic way to write such helper functions, wrappers, etc? So far the only two ideas I have are to name such captured variables guard or add _ = at the end of the scope, but both are not ideal.

(and I guess the hidden question is if move-on-last-use without escape analysis (which would likely complicate the compiler significantly and reduce the number of moves) is a good idea)

[jcanizales]

Does the transpiler really not detect those references? I.e. does it actually break?

[gediminasel]

Examples that I have indeed break, I tested using cppfront compiled from 44a7255

[MumblyJuergens]

I seem to have luck if I save a pointer using the capture, the syntax1 code attempts to move from it on last use, but it does no harm.

example: () = {
    vec: std::vector<int> = (1, 2, 3);

    lambda := :() = {
        v := vec&$;

        std::println("{}", v*[1]);
    };

    lambda();

    std::println("vec size: {}", vec.size());
}

Becomes

auto example() -> void{
    std::vector<int> vec {1, 2, 3}; 

    auto lambda {[_0 = (&vec)]() mutable -> void{
        auto v {_0}; 

        std::println("{}", CPP2_ASSERT_IN_BOUNDS_LITERAL((*cpp2::impl::assert_not_null(cpp2::move(v))), 1));
    }}; 

    cpp2::move(lambda)();

    std::println("vec size: {}", CPP2_UFCS(size)(cpp2::move(vec)));
}

Ouput:
2
vec size: 3

[jcanizales]

Having to go that way is pretty unfortunate though. I wonder if this is a bug that should be fixed in the language.

[gregmarr]

That's because your last use is after the lambda(); call, in the vec.size() call in std::println. If you remove that and do vec2 := vec before the lambda() call, you get the same issue with vec being empty, and you doing an unchecked element access because you "know" how big the vector is.

[gregmarr]

So the issue is that the move on last use isn't recognizing that the lambda has a pointer to the vector, and that pointer potentially extends the "definite last use" location of the vector to be the last use of the lambda.

That sounds like a bug in the "definite last use" tracker.