Auto merge of rust-lang#67485 - Centril:rollup-gt0opvr, r=Centril

Rollup of 7 pull requests

Successful merges:

 - rust-lang#67059 (Fix too restrictive checks on Drop impls)
 - rust-lang#67355 (Merge `ast::Mutability` and `mir::Mutability`)
 - rust-lang#67393 (Enable opting out of specific default LLVM arguments.)
 - rust-lang#67422 (Cleanup err codes)
 - rust-lang#67462 (Make ptr::slice_from_raw_parts a const fn available under a feature flag)
 - rust-lang#67467 (Test slice patterns more)
 - rust-lang#67478 (Fix src/libcore/str/mod.rs doc comments)

Failed merges:

r? @ghost

Author: bors

src/libcore/ptr/mod.rs

@@ -259,7 +259,8 @@ pub(crate) struct FatPtr<T> {
 /// ```
 #[inline]
 #[unstable(feature = "slice_from_raw_parts", reason = "recently added", issue = "36925")]
-pub fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
+#[rustc_const_unstable(feature = "const_slice_from_raw_parts", issue = "67456")]
+pub const fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
     unsafe { Repr { raw: FatPtr { data, len } }.rust }
 }
 
@@ -275,7 +276,8 @@ pub fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
 /// [`from_raw_parts_mut`]: ../../std/slice/fn.from_raw_parts_mut.html
 #[inline]
 #[unstable(feature = "slice_from_raw_parts", reason = "recently added", issue = "36925")]
-pub fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
+#[rustc_const_unstable(feature = "const_slice_from_raw_parts", issue = "67456")]
+pub const fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
     unsafe { Repr { raw: FatPtr { data, len } }.rust_mut }
 }
 

src/libcore/str/mod.rs

@@ -2325,7 +2325,7 @@ impl str {
         i.get_mut(self)
     }
 
-    /// Returns a unchecked subslice of `str`.
+    /// Returns an unchecked subslice of `str`.
     ///
     /// This is the unchecked alternative to indexing the `str`.
     ///

src/libcore/tests/lib.rs

@@ -36,6 +36,9 @@
 #![feature(iter_is_partitioned)]
 #![feature(iter_order_by)]
 #![feature(cmp_min_max_by)]
+#![feature(slice_from_raw_parts)]
+#![feature(const_slice_from_raw_parts)]
+#![feature(const_raw_ptr_deref)]
 
 extern crate test;
 

src/libcore/tests/ptr.rs

@@ -1,6 +1,17 @@
 use core::cell::RefCell;
 use core::ptr::*;
 
+#[test]
+fn test_const_from_raw_parts() {
+    const SLICE: &[u8] = &[1, 2, 3, 4];
+    const FROM_RAW: &[u8] = unsafe { &*slice_from_raw_parts(SLICE.as_ptr(), SLICE.len()) };
+    assert_eq!(SLICE, FROM_RAW);
+
+    let slice = &[1, 2, 3, 4, 5];
+    let from_raw = unsafe { &*slice_from_raw_parts(slice.as_ptr(), 2) } ;
+    assert_eq!(&slice[..2], from_raw);
+}
+
 #[test]
 fn test() {
     unsafe {

src/librustc/hir/lowering.rs

@@ -2253,7 +2253,7 @@ impl<'a> LoweringContext<'a> {
                     let is_mutable_pat = match arg.pat.kind {
                         PatKind::Ident(BindingMode::ByValue(mt), _, _) |
                         PatKind::Ident(BindingMode::ByRef(mt), _, _) =>
-                            mt == Mutability::Mutable,
+                            mt == Mutability::Mut,
                         _ => false,
                     };
 
@@ -2264,7 +2264,7 @@ impl<'a> LoweringContext<'a> {
                         // the case where we have a mutable pattern to a reference as that would
                         // no longer be an `ImplicitSelf`.
                         TyKind::Rptr(_, ref mt) if mt.ty.kind.is_implicit_self() &&
-                            mt.mutbl == ast::Mutability::Mutable =>
+                            mt.mutbl == ast::Mutability::Mut =>
                                 hir::ImplicitSelfKind::MutRef,
                         TyKind::Rptr(_, ref mt) if mt.ty.kind.is_implicit_self() =>
                             hir::ImplicitSelfKind::ImmRef,
@@ -3068,10 +3068,10 @@ impl<'a> LoweringContext<'a> {
 
     fn lower_binding_mode(&mut self, b: &BindingMode) -> hir::BindingAnnotation {
         match *b {
-            BindingMode::ByValue(Mutability::Immutable) => hir::BindingAnnotation::Unannotated,
-            BindingMode::ByRef(Mutability::Immutable) => hir::BindingAnnotation::Ref,
-            BindingMode::ByValue(Mutability::Mutable) => hir::BindingAnnotation::Mutable,
-            BindingMode::ByRef(Mutability::Mutable) => hir::BindingAnnotation::RefMut,
+            BindingMode::ByValue(Mutability::Not) => hir::BindingAnnotation::Unannotated,
+            BindingMode::ByRef(Mutability::Not) => hir::BindingAnnotation::Ref,
+            BindingMode::ByValue(Mutability::Mut) => hir::BindingAnnotation::Mutable,
+            BindingMode::ByRef(Mutability::Mut) => hir::BindingAnnotation::RefMut,
         }
     }
 

src/librustc/hir/lowering/expr.rs

@@ -1340,7 +1340,7 @@ impl LoweringContext<'_> {
     fn expr_mut_addr_of(&mut self, span: Span, e: P<hir::Expr>) -> hir::Expr {
         self.expr(
             span,
-            hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mutable, e),
+            hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e),
             ThinVec::new(),
         )
     }

src/librustc/hir/pat_util.rs

@@ -169,11 +169,10 @@ impl hir::Pat {
         self.each_binding(|annotation, _, _, _| {
             match annotation {
                 hir::BindingAnnotation::Ref => match result {
-                    None | Some(hir::Mutability::Immutable) =>
-                        result = Some(hir::Mutability::Immutable),
+                    None | Some(hir::Mutability::Not) => result = Some(hir::Mutability::Not),
                     _ => {}
                 }
-                hir::BindingAnnotation::RefMut => result = Some(hir::Mutability::Mutable),
+                hir::BindingAnnotation::RefMut => result = Some(hir::Mutability::Mut),
                 _ => {}
             }
         });

src/librustc/hir/print.rs

@@ -386,7 +386,7 @@ impl<'a> State<'a> {
             }
             hir::ForeignItemKind::Static(ref t, m) => {
                 self.head(visibility_qualified(&item.vis, "static"));
-                if m == hir::Mutability::Mutable {
+                if m == hir::Mutability::Mut {
                     self.word_space("mut");
                 }
                 self.print_ident(item.ident);
@@ -502,7 +502,7 @@ impl<'a> State<'a> {
             }
             hir::ItemKind::Static(ref ty, m, expr) => {
                 self.head(visibility_qualified(&item.vis, "static"));
-                if m == hir::Mutability::Mutable {
+                if m == hir::Mutability::Mut {
                     self.word_space("mut");
                 }
                 self.print_ident(item.ident);
@@ -1632,11 +1632,11 @@ impl<'a> State<'a> {
                 match binding_mode {
                     hir::BindingAnnotation::Ref => {
                         self.word_nbsp("ref");
-                        self.print_mutability(hir::Mutability::Immutable, false);
+                        self.print_mutability(hir::Mutability::Not, false);
                     }
                     hir::BindingAnnotation::RefMut => {
                         self.word_nbsp("ref");
-                        self.print_mutability(hir::Mutability::Mutable, false);
+                        self.print_mutability(hir::Mutability::Mut, false);
                     }
                     hir::BindingAnnotation::Unannotated => {}
                     hir::BindingAnnotation::Mutable => {
@@ -2065,8 +2065,8 @@ impl<'a> State<'a> {
 
     pub fn print_mutability(&mut self, mutbl: hir::Mutability, print_const: bool) {
         match mutbl {
-            hir::Mutability::Mutable => self.word_nbsp("mut"),
-            hir::Mutability::Immutable => if print_const { self.word_nbsp("const") },
+            hir::Mutability::Mut => self.word_nbsp("mut"),
+            hir::Mutability::Not => if print_const { self.word_nbsp("const") },
         }
     }
 

src/librustc/lint/internal.rs

@@ -132,7 +132,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TyTyKind {
                     }
                 }
             }
-            TyKind::Rptr(_, MutTy { ty: inner_ty, mutbl: Mutability::Immutable }) => {
+            TyKind::Rptr(_, MutTy { ty: inner_ty, mutbl: Mutability::Not }) => {
                 if let Some(impl_did) = cx.tcx.impl_of_method(ty.hir_id.owner_def_id()) {
                     if cx.tcx.impl_trait_ref(impl_did).is_some() {
                         return;

src/librustc/mir/interpret/allocation.rs

@@ -106,7 +106,7 @@ impl<Tag> Allocation<Tag> {
             undef_mask: UndefMask::new(size, true),
             size,
             align,
-            mutability: Mutability::Immutable,
+            mutability: Mutability::Not,
             extra: (),
         }
     }
@@ -123,7 +123,7 @@ impl<Tag> Allocation<Tag> {
             undef_mask: UndefMask::new(size, false),
             size,
             align,
-            mutability: Mutability::Mutable,
+            mutability: Mutability::Mut,
             extra: (),
         }
     }