document Rust 1.90 changes

[tshepang]

No description provided.

[traviscross]

cc @PLeVasseur @nikomatsakis @joshtriplett

[traviscross]

Two things. One, it's OK for the expression to be subject to drop scope extension. It's not OK for that extension to extend the scope outside of the initializer to the end of the program.

const _: () = { let x = { &mut 0u8 }; x; }; //~ OK
//                             ^^^
// The drop scope of this temporary is extended.

Two, the comma in "..., and which are either..." causes me to read it as a clause independent from "except...". I.e., this says (applying commutativity) "all forms of borrows 1) that are either mutable or result in values with interior mutability and 2) where the expression would not be subject to drop scope extension".

[tshepang]

d261499

[PLeVasseur]

@traviscross -- did this address the issue raised?

[traviscross]

This is correct, except that, if I'm reading the diff correctly, it's putting this language in the list of what constitutes a constant context rather than about what constitutes a constant expression. We're defining constant expressions here, and the existing rules about "borrows" and "immutable borrow expressions" will need to be changed (and then that reflected in the changelog, etc.).

[traviscross]

Two things. One, even with the other rule, this needs to talk about containing a mutable reference rather than being one.

Two, it's not enough to talk about types here. We actually do this reasoning by value, not by type.

trait Tr {}
impl<T: ?Sized> Tr for T {}
static mut X: u8 = 0;
const _: &dyn Tr = unsafe { &&mut X }; //~ ERROR
//       ^^^^^^^
// This type does not contain any mutable references.

[tshepang]

am not sure how to word this simply, given the complexities

[kirtchev-adacore]

I will give this a shot.

The paragraph

The type of a :t:constant cannot be a :t:mutable reference type.

should be removed.

Insert the following after
7.1:8 The value of a constant is determined by evaluating its constant initializer.

The value of a constant cannot contain any mutable references, except when:

• The type of the constant is an immutable reference and the initializer contains a reference to a mutable static, or
• The type of the constant is subject to interior mutability and the initializer contains a reference to a value subject to interior mutability, or
• The type of the constant is a zero-sized type and the initializer contains a reference to a value of a zero-sized type, or
• The initializer contains a reference to an external static.

I am not sure whether the type of the constant plays a role in the external static case.

[traviscross]

The value of a constant cannot contain any mutable references, except when... The initializer contains a reference to an external static.

unsafe extern "C" {
    safe static S1: u8;
}

static mut S2: u8 = 0;

const C: (&u8, &mut u8) = (&S1, unsafe { &mut S2 }); //~ ERROR
//                         ^^^
// The initializer contains a reference to an external static.

[traviscross]

Similarly:

The value of a constant cannot contain any mutable references, except when... The type of the constant is an immutable reference and the initializer contains a reference to a mutable static...

static mut S1: u8 = 0;
static mut S2: u8 = 0;

const C: &(&u8, &mut u8) = unsafe { &(&S1, &mut S2) }; //~ ERROR
//       ^                            ^^^
// The type of the constant is an immutable reference and the
// initializer contains a reference to a mutable static.

[kirtchev-adacore]

How about

The final value of a constant, after the constant initializer is evaluated to a value of the declared type, cannot contain any mutable references except when

• The mutable reference is coercible to an immutable reference, or
• The mutable reference is contained within an external static, or
• The mutable reference is contained within an union, or
• The referent is subject to interior mutability, or
• The referent is of a zero-sized type.

My experiments.

[traviscross]

Right direction, and thanks for doing and posting the experiments. Good process. (Doing such experiments is how @ehuss and I write and review Reference text as well.)

The mutable reference is coercible to an immutable reference, or

This may be a nit, but I'd say that all mutable references are coercible to immutable References; the important thing here is whether that coercion actually happens when evaluating to the final value.

The referent is subject to interior mutability, or

This only allows an immutable reference (to the interior mutable value), not a mutable one (which is what I think the text would imply).

• The mutable reference is contained within an external static, or

There should be a similar rule for being contained in a mutable static.

[kirtchev-adacore]

This only allows an immutable reference (to the interior mutable value), not a mutable one (which is what I think the text would imply).

Are you referring to this case?

static mut MA: AtomicU8 = AtomicU8::new(0);
const _: &AtomicU8 = unsafe { &mut MA };

If yes, then doesn't this case fall under the "the mutable reference is coerced to an immutable reference"?

This case

static mut MA: AtomicU8 = AtomicU8::new(0);
const _: &mut AtomicU8 = unsafe { &mut MA };

is illegal. I think these are the only two cases involving mutable references to values subject to interior mutability.

[traviscross]

The second case is the one I mean. Agreed it's illegal. What rule are we suggesting makes it illegal?

My reading is that this language, by itself, would allow it:

The final value of a constant, after the constant initializer is evaluated to a value of the declared type, cannot contain any mutable references except when... The referent is subject to interior mutability...

[kirtchev-adacore]

Perhaps

The final value of a constant, after the constant initializer is evaluated to a value of the declared type, cannot contain any mutable references except when...

• The type of the constant is an immutable reference and the referent is subject to interior mutability, or ...

Assuming the above is correct, the full set of rules becomes

The final value of a constant, after the constant initializer is evaluated to a value of the declared type, cannot contain any mutable references except when

• The mutable reference is successfully coerced to an immutable reference, or
• The mutable reference is contained within an external static, or
• The mutable reference is contained within an union, or
• The type of the constant is an immutable reference and the referent is subject to interior mutability, or
• The referent is of a zero-sized type.

🙏