Using std::swap in move constructors

[Swat-SomeBug]

I wanted to write a resource handle type in cpp2, to explore the syntax. I came up with this very crude code:

#include <cstdlib>
#include <iostream>
#include <utility>
#include <optional>

resource : type = {
  r_ : std::optional<*int>;

  reset :(inout this) = {
    if r_ {
      free(r_.value()); // Obtained from malloc
      r_ = std::nullopt;
    }
  }

 // v is some resource coming from malloc
  operator= :(out this, v : *int) = {

    r_ = v;

    std::cout << "Constructed\n";

  }

  operator= :(out this, move that) = {
    std::swap(this.r_, that.r_);
    that.reset();
  }


  operator* : (inout this) -> *int = {
    return r_*;
  }


  operator= :(move this) = {

    this.reset();
    std::cout << "Destroyed\n";

  }
}

While the code above has several problems, I'm currently unable to swap this.r_ and that.r_ as std::swap expects lvalues (understandably).
However, cppfront, moves that into std::swap.
Using _ = that; doesn't work here, as I get an error from cppfront regarding a double move.

Is there some guidance in writing resource handles in cpp2 syntax?

[JohelEGP]

Is there some guidance in writing resource handles in cpp2 syntax?

Same guidance as in Cpp1: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-resource.

I honestly don't remember the semantics of move.
And I'm wary enough of operator= being special cased
that I'm not sure it's how it would behave in any other function.
The that.reset() in operator= :(out this, move that) passes that by move,
but reset expects an inout object: reset :(inout this).
There seems to be no way to opt-out of that implicit move.
I do notice that this.reset() in operator= :(move this) works as this is inconsistently not passed by move.

[Swat-SomeBug]

I do notice that this.reset() in operator= :(move this) works as this is inconsistently not passed by move.

Aah, didn't notice it. Is the special handling of that intended?

[Swat-SomeBug]

I further noticed that

operator= :(out this, v : *int)

implicitly generates a Cpp1 assignment operator

auto operator=(int* v) & -> resource&

Is there a way to disable this?

[JohelEGP]

Overloading with a private inout this: #468 (comment).

[realgdman]

@Swat-SomeBug refer to this wiki article https://github.com/hsutter/cppfront/wiki/Cpp2:-operator=,-this-&-that#operator-can-generalize-assignment-from-construction-and-move-from-copy
AFAIR It is by design when you write only some of those operators, cppfront will implicitly provide rest to fill graph. As @JohelEGP you can suppress unneeded explicitly.