Merge pull request #15 from rust-rfcs/const_drop

Explain `Drop` in constants

Author: RalfJung

const.md

@@ -59,6 +59,36 @@ ecosystem that would break if we just started enforcing this now. See
 [this issue](https://github.com/rust-lang/rust/issues/49206) and the
 [PR attempting to fix this](https://github.com/rust-lang/rust/pull/54424/).
 
+### `Drop`
+
+Values of "needs drop" types
+can only be used as the final initialization value of a `const` or `static` item.
+They may not be used as intermediate values that would be dropped before the item
+were initialized. As an example:
+
+```rust
+struct Foo;
+
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("foo dropped");
+    }
+}
+
+const FOO: Foo = Foo; // Ok, drop is run at each use site in runtime code
+static FOOO: Foo = Foo; // Ok, drop is never run
+
+// Not ok, cannot run `Foo::drop` because it's not a const fn
+const BAR: i32 = (Foo, 42).1;
+```
+
+This restriction might be lifted in the future after trait impls
+may be declared `const` (https://github.com/rust-rfcs/const-eval/pull/8).
+
+Note that in promoteds this restriction can never be lifted, because
+otherwise we would silently stop calling the `Drop` impl at runtime and
+pull it to much earlier (compile-time).
+
 ## Reading statics
 
 Beyond values of reference type, we have to be careful that *computing* a

promotion.md

@@ -97,7 +97,19 @@ compile-time instead of run-time should not alter program behavior.
 
 ### 4. Drop
 
-TODO: Fill this with information.
+Expressions containing "needs drop" types
+can never be promoted. If such an expression were promoted, the `Drop` impl would
+never get called on the value, even though the user did not explicitly request such
+behavior by using an explicit `const` or `static` item.
+
+As expression promotion is essentially the silent insertion of a `static` item, and
+`static` items never have their `Drop` impl called, the `Drop` impl of the promoted
+value would never get called.
+
+While it is sound to `std::mem::forget` any value and thus not call its `Drop` impl,
+it is unlikely to be the desired behavior in most cases and very likey to be confusing
+to the user. If such behavior is desired, the user can still use an explicit `static`
+or `const` item and refer to that.
 
 ## Open questions