Rollup of 17 pull requests

compiler/rustc_ast/src/ast.rs

@@ -4096,6 +4096,7 @@ pub struct TestBinderConstraints {
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TestBinderBody {
+    pub span: Span,
     pub foralls: ThinVec<TestBinderForall>,
     pub exists: ThinVec<TestBinderExists>,
     pub constraints: Vec<TestBinderConstraint>,

compiler/rustc_ast_lowering/src/delegation/mod.rs

@@ -51,7 +51,7 @@ use rustc_hir::{self as hir, FnDeclFlags, QPath};
 use rustc_middle::ty::Asyncness;
 use rustc_span::def_id::DefId;
 use rustc_span::symbol::kw;
-use rustc_span::{Ident, Span, Symbol, sym};
+use rustc_span::{Ident, Span, Symbol};
 
 use crate::delegation::generics::{GenericsGenerationResults, GenericsPosition};
 use crate::delegation::resolution::resolver::DelegationResolver;
@@ -480,7 +480,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.arena.alloc_slice(&[hir::ExprField {
                     hir_id: self.next_id(),
                     is_shorthand: false,
-                    ident: Ident::new(sym::integer(0), span),
+                    ident: Ident::new(kw::Underscore, span),
                     expr: self.arena.alloc(call),
                     span,
                 }]),

compiler/rustc_ast_lowering/src/item.rs

@@ -2015,7 +2015,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .iter()
                 .map(|predicate| self.lower_where_predicate(predicate, &[], &mut dedup_map)),
         );
-        hir::TestBinderBody { foralls, exists, constraints, predicates }
+        let span = self.lower_span(body.span);
+        hir::TestBinderBody { foralls, exists, constraints, predicates, span }
     }
 
     fn lower_test_binder_forall(

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -1333,3 +1333,11 @@ pub(crate) struct AbiCustomCannotBeCold {
     #[label("`extern \"custom\"` because of this")]
     pub abi_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("showing the spans of the {$kind}")]
+pub(crate) struct ShowSpan {
+    #[primary_span]
+    pub span: Span,
+    pub kind: &'static str,
+}

compiler/rustc_ast_passes/src/lib.rs

@@ -12,3 +12,4 @@
 pub mod ast_validation;
 mod diagnostics;
 pub mod feature_gate;
+pub mod show_spans;

compiler/rustc_ast_passes/src/show_spans.rs

@@ -0,0 +1,67 @@
+use rustc_ast::visit::{self, Visitor};
+use rustc_ast::{self as ast, ItemKind};
+use rustc_attr_ir::{Attribute, AttributeKind, RustcShowSpansKind};
+use rustc_attr_parsing::AttributeParser;
+use rustc_session::Session;
+use rustc_span::sym;
+
+use crate::diagnostics;
+
+struct ShowSpans<'a> {
+    sess: &'a Session,
+    expr: bool,
+    ty: bool,
+    path: bool,
+}
+
+impl<'a> Visitor<'a> for ShowSpans<'a> {
+    fn visit_item(&mut self, item: &'a ast::Item) {
+        let saved = (self.expr, self.ty, self.path);
+        (self.expr, self.ty, self.path) = (false, false, false);
+
+        if let ItemKind::Fn(_) = &item.kind
+            && let Some(Attribute::Parsed(AttributeKind::RustcShowSpans(kinds))) =
+                AttributeParser::parse_limited_sym(self.sess, &item.attrs, &[sym::rustc_show_spans])
+        {
+            for kind in kinds {
+                match kind {
+                    RustcShowSpansKind::Expr => self.expr = true,
+                    RustcShowSpansKind::Ty => self.ty = true,
+                    RustcShowSpansKind::Path => self.path = true,
+                }
+            }
+        }
+        visit::walk_item(self, item);
+
+        // Recover the state. Needed if we are looking into nested items.
+        (self.expr, self.ty, self.path) = saved;
+    }
+
+    // We override it as to not report attribute paths as paths.
+    fn visit_attribute(&mut self, _: &'a ast::Attribute) {}
+
+    fn visit_expr(&mut self, e: &'a ast::Expr) {
+        if self.expr {
+            self.sess.dcx().emit_note(diagnostics::ShowSpan { span: e.span, kind: "expr" });
+        }
+        visit::walk_expr(self, e);
+    }
+
+    fn visit_ty(&mut self, t: &'a ast::Ty) {
+        if self.ty {
+            self.sess.dcx().emit_note(diagnostics::ShowSpan { span: t.span, kind: "ty" });
+        }
+        visit::walk_ty(self, t);
+    }
+
+    fn visit_path(&mut self, p: &'a ast::Path) {
+        if self.path {
+            self.sess.dcx().emit_note(diagnostics::ShowSpan { span: p.span, kind: "path" });
+        }
+        visit::walk_path(self, p);
+    }
+}
+
+pub fn check_crate(sess: &Session, krate: &ast::Crate) {
+    visit::walk_crate(&mut ShowSpans { sess, expr: false, ty: false, path: false }, krate);
+}

compiler/rustc_attr_ir/src/data_structures.rs

@@ -577,6 +577,13 @@ impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute
     }
 }
 
+#[derive(Clone, Debug, StableHash, Encodable, Decodable, PrintAttribute)]
+pub enum RustcShowSpansKind {
+    Expr,
+    Ty,
+    Path,
+}
+
 #[derive(Clone, Debug, StableHash, Encodable, Decodable, PrintAttribute)]
 pub enum RustcDumpLayoutKind {
     Align,
@@ -1426,6 +1433,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_should_not_be_called_on_const_items]`
     RustcShouldNotBeCalledOnConstItems,
 
+    /// Represents `#[rustc_show_spans]`
+    RustcShowSpans(ThinVec<RustcShowSpansKind>),
+
     /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
     RustcSimdMonomorphizeLaneLimit(Limit),
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -189,6 +189,7 @@ impl AttributeKind {
             RustcRegions => No,
             RustcScalableVector { .. } => Yes,
             RustcShouldNotBeCalledOnConstItems => Yes,
+            RustcShowSpans(_) => No,
             RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate
             RustcSkipDuringMethodDispatch { .. } => No,
             RustcSpecializationTrait => No,
@@ -405,6 +406,7 @@ impl AttributeKind {
             RustcRegions => false,
             RustcScalableVector { .. } => false,
             RustcShouldNotBeCalledOnConstItems => false,
+            RustcShowSpans(_) => false,
             RustcSimdMonomorphizeLaneLimit(..) => false,
             RustcSkipDuringMethodDispatch { .. } => false,
             RustcSpecializationTrait => false,

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -1,5 +1,5 @@
 use rustc_attr_ir::target::{AssocCtxt, MethodKind, Target};
-use rustc_attr_ir::{AttributeKind, RustcDumpLayoutKind};
+use rustc_attr_ir::{AttributeKind, RustcDumpLayoutKind, RustcShowSpansKind};
 use rustc_feature::AttributeStability;
 use rustc_span::{Span, Symbol, sym};
 
@@ -301,3 +301,44 @@ impl NoArgsAttributeParser for RustcDumpVtableParser {
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcDumpVtable;
 }
+
+pub(crate) struct RustcShowSpans;
+
+impl SingleAttributeParser for RustcShowSpans {
+    const PATH: &[Symbol] = &[sym::rustc_show_spans];
+
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+
+    const TEMPLATE: AttributeTemplate = template!(List: &["expr", "ty", "path"]);
+    const STABILITY: AttributeStability = unstable!(rustc_attrs);
+
+    fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
+        let Some(items) = cx.expect_list(args, cx.attr_span) else {
+            return None;
+        };
+
+        let mut result = ThinVec::new();
+        for item in items.mixed() {
+            let Some(arg) = item.meta_item_no_args() else {
+                cx.adcx().expected_not_literal(item.span());
+                continue;
+            };
+            let Some(ident) = arg.ident() else {
+                cx.adcx().expected_identifier(arg.span());
+                return None;
+            };
+            let kind = match ident.name {
+                sym::expr => RustcShowSpansKind::Expr,
+                sym::ty => RustcShowSpansKind::Ty,
+                sym::path => RustcShowSpansKind::Path,
+                _ => {
+                    cx.adcx()
+                        .expected_specific_argument(ident.span, &[sym::expr, sym::ty, sym::path]);
+                    continue;
+                }
+            };
+            result.push(kind);
+        }
+        Some(AttributeKind::RustcShowSpans(result))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -252,6 +252,7 @@ attribute_parsers!(
         Single<RustcObjcClassParser>,
         Single<RustcObjcSelectorParser>,
         Single<RustcScalableVectorParser>,
+        Single<RustcShowSpans>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<RustcSkipDuringMethodDispatchParser>,
         Single<RustcTestMarkerParser>,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -385,6 +385,7 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     // Internal attributes, Testing:
     // ==========================================================================
 
+    sym::rustc_show_spans,
     sym::rustc_effective_visibility,
     sym::rustc_dump_inferred_outlives,
     sym::rustc_capture_analysis,

compiler/rustc_feature/src/unstable.rs

@@ -770,7 +770,7 @@ declare_features! (
     (incomplete, unsafe_fields, "1.85.0", Some(132922)),
     /// Allows const generic parameters to be defined with types that
     /// are not `Sized`, e.g. `fn foo<const N: [u8]>() {`.
-    (incomplete, unsized_const_params, "1.82.0", Some(95174)),
+    (incomplete, unsized_const_params, "1.82.0", Some(128028)),
     /// Allows unsized fn parameters.
     (internal, unsized_fn_params, "1.49.0", Some(48055)),
     /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute.

compiler/rustc_hir/src/hir.rs

@@ -4530,6 +4530,7 @@ impl FnHeader {
 
 #[derive(Debug, Clone, Copy, StableHash)]
 pub struct TestBinderBody<'hir> {
+    pub span: Span,
     pub foralls: &'hir [TestBinderForall<'hir>],
     pub exists: &'hir [TestBinderExists<'hir>],
     /// Constraints to be inserted directly into constraint storage to be proven

compiler/rustc_hir/src/intravisit.rs

@@ -1600,7 +1600,7 @@ pub fn walk_test_binder_body<'v, V: Visitor<'v>>(
     visitor: &mut V,
     body: &'v TestBinderBody<'v>,
 ) -> V::Result {
-    let TestBinderBody { foralls, exists, constraints, predicates } = body;
+    let TestBinderBody { span: _, foralls, exists, constraints, predicates } = body;
     walk_list!(visitor, visit_test_binder_forall, *foralls);
     walk_list!(visitor, visit_test_binder_exists, *exists);
     try_visit!(visitor.visit_test_binder_constraint(&constraints));

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -2380,7 +2380,7 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     pub(super) fn check_test_binder_body(&self, body: TestBinderBody<'tcx>) {
-        let TestBinderBody { foralls, exists, constraints, predicates } = body;
+        let TestBinderBody { span, foralls, exists, constraints, predicates } = body;
         if !predicates.is_empty() {
             for (predicate, span) in predicates {
                 let cause = traits::ObligationCause::misc(span, self.body_def_id);
@@ -2400,6 +2400,10 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
             Ok(()) => constraints,
             Err(_guar) => ty::region_constraint::RegionConstraint::new_true(),
         };
+        if constraints.is_false() {
+            self.tcx().dcx().span_err(span, "top level false constraints are not supported");
+            return;
+        }
 
         self.infcx.register_solver_region_constraint(constraints);
 
@@ -2479,6 +2483,13 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
                 u,
             )
             .with_spans(forall.span);
+            if constraint.is_false() {
+                self.tcx().dcx().span_err(forall.span, "forall evaluated to false");
+                self.infcx.overwrite_solver_region_constraint(
+                    ty::region_constraint::RegionConstraint::new_true(),
+                );
+                return;
+            }
             if let Some(assert_on_exit) = &forall.assert_on_exit {
                 self.check_test_binder_region_constraints(forall.span, assert_on_exit, &constraint);
             }
@@ -2798,6 +2809,7 @@ struct RedundantLifetimeArgsLint<'tcx> {
 
 #[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub(crate) struct TestBinderBody<'tcx> {
+    pub span: Span,
     pub foralls: Vec<TestBinderForall<'tcx>>,
     pub exists: Vec<TestBinderExists<'tcx>>,
     /// Constraints to be inserted directly into constraint storage to be proven

compiler/rustc_hir_analysis/src/collect.rs

@@ -328,7 +328,7 @@ impl<'tcx> ItemCtxt<'tcx> {
         &self,
         item: &hir::TestBinderBody<'tcx>,
     ) -> TestBinderBody<'tcx> {
-        let hir::TestBinderBody { foralls, exists, constraints, predicates } = item;
+        let hir::TestBinderBody { span, foralls, exists, constraints, predicates } = item;
         let foralls = foralls.iter().map(|forall| self.lower_test_binder_forall(forall)).collect();
         let exists = exists.iter().map(|exists| self.lower_test_binder_exists(exists)).collect();
         let constraints = self.lower_test_binder_constraint(&constraints);
@@ -337,7 +337,7 @@ impl<'tcx> ItemCtxt<'tcx> {
             clauses_of::where_predicate_clauses(self, predicate, &mut clauses);
         }
         let predicates = clauses.into_iter().map(|(c, span)| (c.kind(), span)).collect();
-        TestBinderBody { foralls, exists, constraints, predicates }
+        TestBinderBody { span: *span, foralls, exists, constraints, predicates }
     }
 
     #[instrument(level = "debug", skip(self), ret)]