Auto merge of #135260 - matthiaskrgr:rollup-8irqs72, r=matthiaskrgr

Rollup of 6 pull requests
Successful merges:
- #134228 (Exhaustively handle expressions in patterns)
- #135194 (triagebot: mark tidy changes with a more specific `A-tidy` label)
- #135222 (Ensure that we don't try to access fields on a non-struct pattern type)
- #135250 (A couple simple borrowck cleanups)
- #135252 (Fix release notes link)
- #135253 (Revert #131365)
Failed merges:
- #135195 (Make `lit_to_mir_constant` and `lit_to_const` infallible)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

RELEASES.md

@@ -37,7 +37,7 @@ Libraries
 - [Move `<float>::copysign`, `<float>::abs`, `<float>::signum` to `core`](https://github.com/rust-lang/rust/pull/131304)
 - [Add `LowerExp` and `UpperExp` implementations to `NonZero`](https://github.com/rust-lang/rust/pull/131377)
 - [Implement `FromStr` for `CString` and `TryFrom<CString>` for `String`](https://github.com/rust-lang/rust/pull/130608)
-- [`std::os::darwin` has been made public](https://github.com/rust-lang/rust/pull/130635)
+- [`std::os::darwin` has been made public](https://github.com/rust-lang/rust/pull/123723)
 
 <a id="1.84.0-Stabilized-APIs"></a>
 

compiler/rustc_ast/src/ast.rs

@@ -623,7 +623,7 @@ impl Pat {
 PatKind::Wild
  | PatKind::Rest
  | PatKind::Never
- | PatKind::Lit(_)
+ | PatKind::Expr(_)
  | PatKind::Range(..)
  | PatKind::Ident(..)
  | PatKind::Path(..)
@@ -801,8 +801,8 @@ pub enum PatKind {
 /// A reference pattern (e.g., `&mut (a, b)`).
 Ref(P<Pat>,Mutability),
 
-/// A literal.
-Lit(P<Expr>),
+/// A literal, const block or path.
+Expr(P<Expr>),
 
 /// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
 Range(Option<P<Expr>>,Option<P<Expr>>,Spanned<RangeEnd>),

compiler/rustc_ast/src/mut_visit.rs

@@ -1512,7 +1512,7 @@ pub fn walk_pat<T: MutVisitor>(vis: &mut T, pat: &mut P<Pat>) {
  vis.visit_ident(ident);
 visit_opt(sub, |sub| vis.visit_pat(sub));
 }
-PatKind::Lit(e) => vis.visit_expr(e),
+PatKind::Expr(e) => vis.visit_expr(e),
 PatKind::TupleStruct(qself, path, elems) => {
  vis.visit_qself(qself);
  vis.visit_path(path);

compiler/rustc_ast/src/visit.rs

@@ -680,7 +680,7 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) -> V::Res
 try_visit!(visitor.visit_ident(ident));
 visit_opt!(visitor, visit_pat, optional_subpattern);
 }
-PatKind::Lit(expression) => try_visit!(visitor.visit_expr(expression)),
+PatKind::Expr(expression) => try_visit!(visitor.visit_expr(expression)),
 PatKind::Range(lower_bound, upper_bound, _end) => {
 visit_opt!(visitor, visit_expr, lower_bound);
 visit_opt!(visitor, visit_expr, upper_bound);

compiler/rustc_ast_lowering/src/expr.rs

@@ -102,17 +102,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
 let kind = match&e.kind{
 ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
-ExprKind::ConstBlock(c) => {
-let c = self.with_new_scopes(c.value.span, |this| {
-let def_id = this.local_def_id(c.id);
- hir::ConstBlock{
- def_id,
-hir_id: this.lower_node_id(c.id),
-body: this.lower_const_body(c.value.span,Some(&c.value)),
-}
-});
- hir::ExprKind::ConstBlock(c)
-}
+ExprKind::ConstBlock(c) => hir::ExprKind::ConstBlock(self.lower_const_block(c)),
 ExprKind::Repeat(expr, count) => {
 let expr = self.lower_expr(expr);
 let count = self.lower_array_length_to_const_arg(count);
@@ -153,18 +143,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 let ohs = self.lower_expr(ohs);
  hir::ExprKind::Unary(op, ohs)
 }
-ExprKind::Lit(token_lit) => {
-let lit_kind = matchLitKind::from_token_lit(*token_lit){
-Ok(lit_kind) => lit_kind,
-Err(err) => {
-let guar =
-report_lit_error(&self.tcx.sess.psess, err,*token_lit, e.span);
-LitKind::Err(guar)
-}
-};
-let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind));
- hir::ExprKind::Lit(lit)
-}
+ExprKind::Lit(token_lit) => hir::ExprKind::Lit(self.lower_lit(token_lit, e.span)),
 ExprKind::IncludedBytes(bytes) => {
 let lit = self.arena.alloc(respan(
 self.lower_span(e.span),
@@ -403,6 +382,32 @@ impl<'hir> LoweringContext<'_, 'hir> {
 })
 }
 
+pub(crate)fnlower_const_block(&mutself,c:&AnonConst) -> hir::ConstBlock{
+self.with_new_scopes(c.value.span, |this| {
+let def_id = this.local_def_id(c.id);
+ hir::ConstBlock{
+ def_id,
+hir_id: this.lower_node_id(c.id),
+body: this.lower_const_body(c.value.span,Some(&c.value)),
+}
+})
+}
+
+pub(crate)fnlower_lit(
+&mutself,
+token_lit:&token::Lit,
+span:Span,
+) -> &'hirSpanned<LitKind>{
+let lit_kind = matchLitKind::from_token_lit(*token_lit){
+Ok(lit_kind) => lit_kind,
+Err(err) => {
+let guar = report_lit_error(&self.tcx.sess.psess, err,*token_lit, span);
+LitKind::Err(guar)
+}
+};
+self.arena.alloc(respan(self.lower_span(span), lit_kind))
+}
+
 fnlower_unop(&mutself,u:UnOp) -> hir::UnOp{
 match u {
 UnOp::Deref => hir::UnOp::Deref,

compiler/rustc_ast_lowering/src/index.rs

@@ -209,6 +209,14 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
 });
 }
 
+fnvisit_pat_expr(&mutself,expr:&'hirPatExpr<'hir>){
+self.insert(expr.span, expr.hir_id,Node::PatExpr(expr));
+
+self.with_parent(expr.hir_id, |this| {
+ intravisit::walk_pat_expr(this, expr);
+});
+}
+
 fnvisit_pat_field(&mutself,field:&'hirPatField<'hir>){
 self.insert(field.span, field.hir_id,Node::PatField(field));
 self.with_parent(field.hir_id, |this| {

compiler/rustc_ast_lowering/src/lib.rs

@@ -35,6 +35,7 @@
 #![doc(rust_logo)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
+#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
 #![warn(unreachable_pub)]

compiler/rustc_ast_lowering/src/pat.rs

@@ -1,9 +1,12 @@
+use std::sync::Arc;
+
 use rustc_ast::ptr::P;
 use rustc_ast::*;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_span::source_map::Spanned;
+use rustc_middle::span_bug;
+use rustc_span::source_map::{Spanned, respan};
 use rustc_span::{Ident,Span};
 
 usesuper::errors::{
@@ -35,8 +38,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  lower_sub,
 );
 }
-PatKind::Lit(e) => {
-break hir::PatKind::Lit(self.lower_expr_within_pat(e,false));
+PatKind::Expr(e) => {
+break hir::PatKind::Expr(self.lower_expr_within_pat(e,false));
 }
 PatKind::TupleStruct(qself, path, pats) => {
 let qpath = self.lower_qpath(
@@ -367,24 +370,54 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 // }
 // m!(S);
 // ```
-fnlower_expr_within_pat(&mutself,expr:&Expr,allow_paths:bool) -> &'hir hir::Expr<'hir>{
-match&expr.kind{
-ExprKind::Lit(..)
- | ExprKind::ConstBlock(..)
- | ExprKind::IncludedBytes(..)
- | ExprKind::Err(_)
- | ExprKind::Dummy => {}
-ExprKind::Path(..)if allow_paths => {}
-ExprKind::Unary(UnOp::Neg, inner)ifmatches!(inner.kind,ExprKind::Lit(_)) => {}
+fnlower_expr_within_pat(
+&mutself,
+expr:&Expr,
+allow_paths:bool,
+) -> &'hir hir::PatExpr<'hir>{
+let err = |guar| hir::PatExprKind::Lit{
+lit:self.arena.alloc(respan(self.lower_span(expr.span),LitKind::Err(guar))),
+negated:false,
+};
+let kind = match&expr.kind{
+ExprKind::Lit(lit) => {
+ hir::PatExprKind::Lit{lit:self.lower_lit(lit, expr.span),negated:false}
+}
+ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c)),
+ExprKind::IncludedBytes(bytes) => hir::PatExprKind::Lit{
+lit:self.arena.alloc(respan(
+self.lower_span(expr.span),
+LitKind::ByteStr(Arc::clone(bytes),StrStyle::Cooked),
+)),
+negated:false,
+},
+ExprKind::Err(guar) => err(*guar),
+ExprKind::Dummy => span_bug!(expr.span,"lowered ExprKind::Dummy"),
+ExprKind::Path(qself, path)if allow_paths => hir::PatExprKind::Path(self.lower_qpath(
+ expr.id,
+ qself,
+ path,
+ParamMode::Optional,
+AllowReturnTypeNotation::No,
+ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+None,
+)),
+ExprKind::Unary(UnOp::Neg, inner)ifletExprKind::Lit(lit) = &inner.kind => {
+ hir::PatExprKind::Lit{lit:self.lower_lit(lit, expr.span),negated:true}
+}
  _ => {
 let pattern_from_macro = expr.is_approximately_pattern();
 let guar = self.dcx().emit_err(ArbitraryExpressionInPattern{
 span: expr.span,
 pattern_from_macro_note: pattern_from_macro,
 });
-returnself.arena.alloc(self.expr_err(expr.span,guar));
+err(guar)
 }
-}
-self.lower_expr(expr)
+};
+self.arena.alloc(hir::PatExpr{
+hir_id:self.lower_node_id(expr.id),
+span: expr.span,
+ kind,
+})
 }
 }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1701,7 +1701,7 @@ impl<'a> State<'a> {
 self.print_pat(inner);
 }
 }
-PatKind::Lit(e) => self.print_expr(e,FixupContext::default()),
+PatKind::Expr(e) => self.print_expr(e,FixupContext::default()),
 PatKind::Range(begin, end,Spanned{node: end_kind, .. }) => {
 ifletSome(e) = begin {
 self.print_expr(e,FixupContext::default());

compiler/rustc_borrowck/src/consumers.rs

@@ -11,8 +11,8 @@ pub use super::dataflow::{BorrowIndex, Borrows, calculate_borrows_out_of_scope_a
 pubusesuper::place_ext::PlaceExt;
 pubusesuper::places_conflict::{PlaceConflictBias, places_conflict};
 pubusesuper::polonius::legacy::{
-AllFactsasPoloniusInput,LocationTable,PoloniusOutput,PoloniusRegionVid,RichLocation,
-RustcFacts,
+PoloniusFactsasPoloniusInput,PoloniusLocationTable,PoloniusOutput,PoloniusRegionVid,
+RichLocation,RustcFacts,
 };
 pubusesuper::region_infer::RegionInferenceContext;
 
@@ -33,7 +33,7 @@ pub enum ConsumerOptions {
 /// without significant slowdowns.
 ///
 /// Implies [`RegionInferenceContext`](ConsumerOptions::RegionInferenceContext),
-/// and additionally retrieve the [`LocationTable`] and [`PoloniusInput`] that
+/// and additionally retrieve the [`PoloniusLocationTable`] and [`PoloniusInput`] that
 /// would be given to Polonius. Critically, this does not run Polonius, which
 /// one may want to avoid due to performance issues on large bodies.
 PoloniusInputFacts,
@@ -71,7 +71,7 @@ pub struct BodyWithBorrowckFacts<'tcx> {
 /// The table that maps Polonius points to locations in the table.
 /// Populated when using [`ConsumerOptions::PoloniusInputFacts`]
 /// or [`ConsumerOptions::PoloniusOutputFacts`].
-publocation_table:Option<LocationTable>,
+publocation_table:Option<PoloniusLocationTable>,
 /// Polonius input facts.
 /// Populated when using [`ConsumerOptions::PoloniusInputFacts`]
 /// or [`ConsumerOptions::PoloniusOutputFacts`].