In-place memberwise initializers

[tothambrus11]

TODO summarize existing approaches (see Slack).

Having an inplace parameter passing convention specifically for initializers could simplify the semantics and compilation of memberwise init, and make it expressible with a user-defined initializer. Specifically, memberwise init would desugar to a regular initializer with all its parameters passed via the inplace convention.

Consider the following code in Hylo:

struct B {
  let x: SomeImmovable
  let y: SomeMovable

  /// Requires `SomeMovable is Movable`.
  init(x: inplace Int, y: sink Int) {
    print("Hello, world!")
    &self.y = y
  }
}

// MARK: Resilience boundary

fun app() {
  let b = B(SomeImmovable(5), SomeMovable())
}

This would be lowered to an in-place initialization on the call site, followed by a call to the init function, which now only has y as a parameter:

struct B {
  SomeImmovable x;
  SomeMovable y;
};

const uint32_t B_offset_of_x = offsetof(B, x);
const uint32_t B_offset_of_y = offsetof(B, y);

void B_init(B *self, SomeMovable *y) {
  printf("Hello, world!");
  self->y = std::move(*y);
}

// resilience boundary

extern const uint32_t B_offset_of_x;
extern const uint32_t B_offset_of_y;

void app() {
  // Allocate storage for an instance of `B`.
  B* b = (B*) alloca(sizeof(B));

  // Construct 5 in-place to member `x` of `b`:
  std::construct_at<SomeImmovable>((SomeImmovable *)(((char *)&b) + B_offset_of_x), 5);

  /// Construct `y` out of line, then move its value inside `B_init`:
  SomeMovable y = SomeMovable();
  B_init(b, &y);
}

We can add knobs to control what we promise about the ABI:

• inplace memberwise init or sinking memberwise init - the latter would accept members as sink arguments, requiring Movable conformance. The former locks in that the current stored properties remain stored properties forever (though it allows reordering and adding new stored properties). Whether which one should be the implicit default is to be decided.
• noncustom memberwise init: Indicate if want to promise that we won't want to rewrite the initializer to a user-defined initializer with custom initializer body. This would prevent us from adding extra fields without breaking ABI, since we would need to initialize those somewhere.