Removal of all unstable placement features

announcements
2

A comment on the tracking issue asks:

Would it be possible to just avoid all the issues brought up with placement syntax and provide a ptr::write like intrinsic that allowed directly writing a static Struct to a pointer as a stop-gap solution? As is, Rust does not really support large structs, because they're always allocated on the stack before writing, resulting in stack overflows. This would fill the basic need, while leaving all the other questions until later.

("static Struct" may refer to some &'static Struct stored in the .data section in which case many questions below are irrelevant, but I'll address the more general point anyway)

Regarding reduced proposals: I personally could imagine an RFC with a smaller scope (the summary comment hints at this at one point) as long as

  1. we're happy the RFC is forward compatible with strange things we may want in the future
  2. the RFC is crystal clear on the placement guarantees provided

2 may require a touch more thought than you'd expect. place <- [0; 1024] should obviously work. let x = 1u8; place <- S { field: [[[0; 1024], [x; 1024]]] } should probably also work. place <- S { field: [0; 1024], field2: foo() } probably won't work, but is this a bit unintuitive if foo just returns a usize? Perhaps the consistent rule is "no function calls to the right of a placement operator". But what about let someval; place <- S { field: { someval = 4; [0; 1024] } }? And did you know that you can take the address of an enum variant and use it as a function [0]? Does that make constructing one a function call?

I think I personally have a reasonable intuition of what it means to be an "easily-placeable value expression" and can answer the questions above, but when writing an RFC I'd probably have to resort to exhaustively listing possibilities.

[0]

enum X { A(u8) }
let xf = X::A;
let x = xf(1);