Auto merge of #150537 - Zalathar:rollup-ddm3q0n, r=Zalathar

Rollup of 4 pull requests

Successful merges:

 - #143741 (`oneshot` Channel)
 - #146798 (RISC-V: Implement (Zkne or Zknd) intrinsics correctly)
 - #150337 (docs: fix typo in std::io::buffered)
 - #150530 (Remove `feature(string_deref_patterns)`)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -262,6 +262,11 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
             "power8-crypto" => Some(LLVMFeature::new("crypto")),
             s => Some(LLVMFeature::new(s)),
         },
+        Arch::RiscV32 | Arch::RiscV64 => match s {
+            // Filter out Rust-specific *virtual* target feature
+            "zkne_or_zknd" => None,
+            s => Some(LLVMFeature::new(s)),
+        },
         Arch::Sparc | Arch::Sparc64 => match s {
             "leoncasa" => Some(LLVMFeature::new("hasleoncasa")),
             s => Some(LLVMFeature::new(s)),

compiler/rustc_feature/src/removed.rs

@@ -271,6 +271,8 @@ declare_features! (
     /// Allows `#[link(kind = "static-nobundle", ...)]`.
     (removed, static_nobundle, "1.63.0", Some(37403),
      Some(r#"subsumed by `#[link(kind = "static", modifiers = "-bundle", ...)]`"#), 95818),
+    /// Allows string patterns to dereference values to match them.
+    (removed, string_deref_patterns, "CURRENT_RUSTC_VERSION", Some(87121), Some("superseded by `deref_patterns`"), 150530),
     (removed, struct_inherit, "1.0.0", None, None),
     (removed, test_removed_feature, "1.0.0", None, None),
     /// Allows using items which are missing stability attributes

compiler/rustc_feature/src/unstable.rs

@@ -647,8 +647,6 @@ declare_features! (
     (unstable, stmt_expr_attributes, "1.6.0", Some(15701)),
     /// Allows lints part of the strict provenance effort.
     (unstable, strict_provenance_lints, "1.61.0", Some(130351)),
-    /// Allows string patterns to dereference values to match them.
-    (unstable, string_deref_patterns, "1.67.0", Some(87121)),
     /// Allows `super let` statements.
     (unstable, super_let, "1.88.0", Some(139076)),
     /// Allows subtrait items to shadow supertrait items.

compiler/rustc_hir_typeck/src/pat.rs

@@ -996,20 +996,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             pat_ty = self.tcx.types.str_;
         }
 
-        if self.tcx.features().string_deref_patterns()
-            && let hir::PatExprKind::Lit {
-                lit: Spanned { node: ast::LitKind::Str(..), .. }, ..
-            } = lt.kind
-        {
-            let tcx = self.tcx;
-            let expected = self.resolve_vars_if_possible(expected);
-            pat_ty = match expected.kind() {
-                ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::String) => expected,
-                ty::Str => Ty::new_static_str(tcx),
-                _ => pat_ty,
-            };
-        }
-
         // Somewhat surprising: in this case, the subtyping relation goes the
         // opposite way as the other cases. Actually what we really want is not
         // a subtyping relation at all but rather that there exists a LUB

compiler/rustc_middle/src/thir.rs

@@ -827,7 +827,6 @@ pub enum PatKind<'tcx> {
     ///   much simpler.
     /// * raw pointers derived from integers, other raw pointers will have already resulted in an
     ///   error.
-    /// * `String`, if `string_deref_patterns` is enabled.
     Constant {
         value: ty::Value<'tcx>,
     },

compiler/rustc_mir_build/src/builder/matches/test.rs

@@ -150,7 +150,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let mut expect = self.literal_operand(test.span, Const::from_ty_value(tcx, value));
 
                 let mut place = place;
-                let mut block = block;
+
                 match cast_ty.kind() {
                     ty::Str => {
                         // String literal patterns may have type `str` if `deref_patterns` is
@@ -175,34 +175,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         place = ref_place;
                         cast_ty = ref_str_ty;
                     }
-                    ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::String) => {
-                        if !tcx.features().string_deref_patterns() {
-                            span_bug!(
-                                test.span,
-                                "matching on `String` went through without enabling string_deref_patterns"
-                            );
-                        }
-                        let re_erased = tcx.lifetimes.re_erased;
-                        let ref_str_ty = Ty::new_imm_ref(tcx, re_erased, tcx.types.str_);
-                        let ref_str = self.temp(ref_str_ty, test.span);
-                        let eq_block = self.cfg.start_new_block();
-                        // `let ref_str: &str = <String as Deref>::deref(&place);`
-                        self.call_deref(
-                            block,
-                            eq_block,
-                            place,
-                            Mutability::Not,
-                            cast_ty,
-                            ref_str,
-                            test.span,
-                        );
-                        // Since we generated a `ref_str = <String as Deref>::deref(&place) -> eq_block` terminator,
-                        // we need to add all further statements to `eq_block`.
-                        // Similarly, the normal test code should be generated for the `&str`, instead of the `String`.
-                        block = eq_block;
-                        place = ref_str;
-                        cast_ty = ref_str_ty;
-                    }
                     &ty::Pat(base, _) => {
                         assert_eq!(cast_ty, value.ty);
                         assert!(base.is_trivially_pure_clone_copy());

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -11,7 +11,7 @@ use rustc_abi::{FieldIdx, Integer};
 use rustc_errors::codes::*;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::pat_util::EnumerateAndAdjustIterator;
-use rustc_hir::{self as hir, LangItem, RangeEnd};
+use rustc_hir::{self as hir, RangeEnd};
 use rustc_index::Idx;
 use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
@@ -626,23 +626,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 // the pattern's type will be `&[u8]` whereas the literal's type is `&[u8; 3]`; using the
                 // pattern's type means we'll properly translate it to a slice reference pattern. This works
                 // because slices and arrays have the same valtree representation.
-                // HACK: As an exception, use the literal's type if `pat_ty` is `String`; this can happen if
-                // `string_deref_patterns` is enabled. There's a special case for that when lowering to MIR.
-                // FIXME(deref_patterns): This hack won't be necessary once `string_deref_patterns` is
-                // superseded by a more general implementation of deref patterns.
                 let ct_ty = match pat_ty {
-                    Some(pat_ty)
-                        if let ty::Adt(def, _) = *pat_ty.kind()
-                            && self.tcx.is_lang_item(def.did(), LangItem::String) =>
-                    {
-                        if !self.tcx.features().string_deref_patterns() {
-                            span_bug!(
-                                expr.span,
-                                "matching on `String` went through without enabling string_deref_patterns"
-                            );
-                        }
-                        self.typeck_results.node_type(expr.hir_id)
-                    }
                     Some(pat_ty) => pat_ty,
                     None => self.typeck_results.node_type(expr.hir_id),
                 };

compiler/rustc_target/src/target_features.rs

@@ -690,8 +690,9 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("zimop", Unstable(sym::riscv_target_feature), &[]),
     ("zk", Stable, &["zkn", "zkr", "zkt"]),
     ("zkn", Stable, &["zbkb", "zbkc", "zbkx", "zkne", "zknd", "zknh"]),
-    ("zknd", Stable, &[]),
-    ("zkne", Stable, &[]),
+    ("zknd", Stable, &["zkne_or_zknd"]),
+    ("zkne", Stable, &["zkne_or_zknd"]),
+    ("zkne_or_zknd", Unstable(sym::riscv_target_feature), &[]), // Not an extension
     ("zknh", Stable, &[]),
     ("zkr", Stable, &[]),
     ("zks", Stable, &["zbkb", "zbkc", "zbkx", "zksed", "zksh"]),

library/std/src/io/buffered/bufreader/buffer.rs

@@ -48,7 +48,7 @@ impl Buffer {
 
     #[inline]
     pub fn buffer(&self) -> &[u8] {
-        // SAFETY: self.pos and self.cap are valid, and self.cap => self.pos, and
+        // SAFETY: self.pos and self.filled are valid, and self.filled >= self.pos, and
         // that region is initialized because those are all invariants of this type.
         unsafe { self.buf.get_unchecked(self.pos..self.filled).assume_init_ref() }
     }

library/std/src/io/buffered/linewritershim.rs

@@ -52,7 +52,7 @@ impl<'a, W: ?Sized + Write> LineWriterShim<'a, W> {
 }
 
 impl<'a, W: ?Sized + Write> Write for LineWriterShim<'a, W> {
-    /// Writes some data into this BufReader with line buffering.
+    /// Writes some data into this BufWriter with line buffering.
     ///
     /// This means that, if any newlines are present in the data, the data up to
     /// the last newline is sent directly to the underlying writer, and data
@@ -146,7 +146,7 @@ impl<'a, W: ?Sized + Write> Write for LineWriterShim<'a, W> {
         self.buffer.flush()
     }
 
-    /// Writes some vectored data into this BufReader with line buffering.
+    /// Writes some vectored data into this BufWriter with line buffering.
     ///
     /// This means that, if any newlines are present in the data, the data up to
     /// and including the buffer containing the last newline is sent directly to
@@ -256,7 +256,7 @@ impl<'a, W: ?Sized + Write> Write for LineWriterShim<'a, W> {
         self.inner().is_write_vectored()
     }
 
-    /// Writes some data into this BufReader with line buffering.
+    /// Writes some data into this BufWriter with line buffering.
     ///
     /// This means that, if any newlines are present in the data, the data up to
     /// the last newline is sent directly to the underlying writer, and data