rust-lang · matthiaskrgr · Mar 12, 2023 · Mar 14, 2023 · Mar 15, 2023 · Mar 15, 2023
diff --git a/compiler/rustc_ast/src/util/parser.rs b/compiler/rustc_ast/src/util/parser.rs
@@ -259,7 +259,6 @@ pub enum ExprPrecedence {
     Assign,
     AssignOp,
 
-    Box,
     AddrOf,
     Let,
     Unary,
@@ -319,8 +318,7 @@ impl ExprPrecedence {
             ExprPrecedence::AssignOp => AssocOp::Assign.precedence() as i8,
 
             // Unary, prefix
-            ExprPrecedence::Box
-            | ExprPrecedence::AddrOf
+            ExprPrecedence::AddrOf
             // Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
             // However, this is not exactly right. When `let _ = a` is the LHS of a binop we
             // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`

diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
@@ -286,10 +286,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             segment_ident_span.find_ancestor_inside(path_span).unwrap_or(path_span)
         } else if generic_args.is_empty() {
             // If there are brackets, but not generic arguments, then use the opening bracket
-            generic_args.span.with_hi(generic_args.span.lo() + BytePos(1))
+            self.tcx
+                .mark_span_for_resize(generic_args.span)
+                .with_hi(generic_args.span.lo() + BytePos(1))
         } else {
             // Else use an empty span right after the opening bracket.
-            generic_args.span.with_lo(generic_args.span.lo() + BytePos(1)).shrink_to_lo()
+            self.tcx
+                .mark_span_for_resize(generic_args.span)
+                .with_lo(generic_args.span.lo() + BytePos(1))
+                .shrink_to_lo()
         };
 
         generic_args.args.insert_many(

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -2073,12 +2073,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             Ok(string) => {
                 if string.starts_with("async ") {
                     let pos = args_span.lo() + BytePos(6);
-                    (args_span.with_lo(pos).with_hi(pos), "move ")
+                    (
+                        self.infcx.tcx.mark_span_for_resize(args_span).with_lo(pos).with_hi(pos),
+                        "move ",
+                    )
                 } else if string.starts_with("async|") {
                     let pos = args_span.lo() + BytePos(5);
-                    (args_span.with_lo(pos).with_hi(pos), " move")
+                    (
+                        self.infcx.tcx.mark_span_for_resize(args_span).with_lo(pos).with_hi(pos),
+                        " move",
+                    )
                 } else {
-                    (args_span.shrink_to_lo(), "move ")
+                    (self.infcx.tcx.mark_span_for_resize(args_span).shrink_to_lo(), "move ")
                 }
             }
             Err(_) => (args_span, "move |<args>| <body>"),

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -457,15 +457,15 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         match self.infcx.tcx.sess.source_map().span_to_snippet(span) {
             Ok(snippet) if snippet.starts_with('*') => {
                 err.span_suggestion_verbose(
-                    span.with_hi(span.lo() + BytePos(1)),
+                    self.infcx.tcx.mark_span_for_resize(span).with_hi(span.lo() + BytePos(1)),
                     "consider removing the dereference here",
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
             }
             _ => {
                 err.span_suggestion_verbose(
-                    span.shrink_to_lo(),
+                    self.infcx.tcx.mark_span_for_resize(span).shrink_to_lo(),
                     "consider borrowing here",
                     '&',
                     Applicability::MaybeIncorrect,

diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -255,7 +255,7 @@ fn sccs_info<'cx, 'tcx>(
     let var_to_origin = infcx.reg_var_to_origin.borrow();
 
     let mut var_to_origin_sorted = var_to_origin.clone().into_iter().collect::<Vec<_>>();
-    var_to_origin_sorted.sort_by(|a, b| a.0.cmp(&b.0));
+    var_to_origin_sorted.sort_by_key(|vto| vto.0);
     let mut debug_str = "region variables to origins:\n".to_string();
     for (reg_var, origin) in var_to_origin_sorted.into_iter() {
         debug_str.push_str(&format!("{:?}: {:?}\n", reg_var, origin));
@@ -2216,7 +2216,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // is in the same SCC or something. In that case, find what
         // appears to be the most interesting point to report to the
         // user via an even more ad-hoc guess.
-        categorized_path.sort_by(|p0, p1| p0.category.cmp(&p1.category));
+        categorized_path.sort_by_key(|p| p.category);
         debug!("sorted_path={:#?}", categorized_path);
 
         (categorized_path.remove(0), extra_info)

diff --git a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
@@ -20,16 +20,16 @@ pub fn expand(
 
     // Allow using `#[alloc_error_handler]` on an item statement
     // FIXME - if we get deref patterns, use them to reduce duplication here
-    let (item, is_stmt, sig_span) =
+    let (item, is_stmt, sig) =
         if let Annotatable::Item(item) = &item
             && let ItemKind::Fn(fn_kind) = &item.kind
         {
-            (item, false, ecx.with_def_site_ctxt(fn_kind.sig.span))
+            (item, false, &fn_kind.sig)
         } else if let Annotatable::Stmt(stmt) = &item
             && let StmtKind::Item(item) = &stmt.kind
             && let ItemKind::Fn(fn_kind) = &item.kind
         {
-            (item, true, ecx.with_def_site_ctxt(fn_kind.sig.span))
+            (item, true, &fn_kind.sig)
         } else {
             ecx.sess.parse_sess.span_diagnostic.span_err(item.span(), "alloc_error_handler must be a function");
             return vec![orig_item];
@@ -39,10 +39,10 @@ pub fn expand(
     let span = ecx.with_def_site_ctxt(item.span);
 
     // Generate item statements for the allocator methods.
-    let stmts = thin_vec![generate_handler(ecx, item.ident, span, sig_span)];
+    let stmts = thin_vec![generate_handler(ecx, item.ident, span, sig)];
 
     // Generate anonymous constant serving as container for the allocator methods.
-    let const_ty = ecx.ty(sig_span, TyKind::Tup(ThinVec::new()));
+    let const_ty = ecx.ty(ecx.with_def_site_ctxt(sig.span), TyKind::Tup(ThinVec::new()));
     let const_body = ecx.expr_block(ecx.block(span, stmts));
     let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
     let const_item = if is_stmt {
@@ -59,27 +59,31 @@ pub fn expand(
 // unsafe fn __rg_oom(size: usize, align: usize) -> ! {
 //     handler(core::alloc::Layout::from_size_align_unchecked(size, align))
 // }
-fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span) -> Stmt {
+fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig: &FnSig) -> Stmt {
     let usize = cx.path_ident(span, Ident::new(sym::usize, span));
     let ty_usize = cx.ty_path(usize);
     let size = Ident::from_str_and_span("size", span);
     let align = Ident::from_str_and_span("align", span);
 
+    let sig_span = cx.with_def_site_ctxt(sig.span);
+    let ret_sp = cx.with_def_site_ctxt(sig.decl.output.span());
+
+    // core::alloc::Layout::from_size_align_unchecked(size, align)
     let layout_new = cx.std_path(&[sym::alloc, sym::Layout, sym::from_size_align_unchecked]);
     let layout_new = cx.expr_path(cx.path(span, layout_new));
     let layout = cx.expr_call(
-        span,
+        cx.with_def_site_ctxt(sig.decl.inputs.get(0).map_or(span, |p| p.span)),
         layout_new,
         thin_vec![cx.expr_ident(span, size), cx.expr_ident(span, align)],
     );
-
-    let call = cx.expr_call_ident(sig_span, handler, thin_vec![layout]);
+    let call =
+        cx.expr(ret_sp, ast::ExprKind::Call(cx.expr_ident(span, handler), thin_vec![layout]));
 
     let never = ast::FnRetTy::Ty(cx.ty(span, TyKind::Never));
     let params = thin_vec![cx.param(span, size, ty_usize.clone()), cx.param(span, align, ty_usize)];
     let decl = cx.fn_decl(params, never);
     let header = FnHeader { unsafety: Unsafe::Yes(span), ..FnHeader::default() };
-    let sig = FnSig { decl, header, span: span };
+    let sig = FnSig { decl, header, span };
 
     let body = Some(cx.block_expr(call));
     let kind = ItemKind::Fn(Box::new(Fn {

diff --git a/compiler/rustc_builtin_macros/src/derive.rs b/compiler/rustc_builtin_macros/src/derive.rs
@@ -138,7 +138,7 @@ fn report_unexpected_meta_item_lit(sess: &Session, lit: &ast::MetaItemLit) {
         }
         _ => "for example, write `#[derive(Debug)]` for `Debug`".to_string(),
     };
-    struct_span_err!(sess, lit.span, E0777, "expected path to a trait, found literal",)
+    struct_span_err!(sess, lit.span, E0777, "expected path to a trait, found literal")
         .span_label(lit.span, "not a trait")
         .help(&help_msg)
         .emit();

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1199,15 +1199,17 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
                     .and_then(|(lhs, rhs)| rhs.chars().all(char::is_numeric).then_some(lhs))
                     .unwrap_or(stem);
 
-                // GCC can have an optional target prefix.
+                // GCC/Clang can have an optional target prefix.
                 let flavor = if stem == "emcc" {
                     LinkerFlavor::EmCc
                 } else if stem == "gcc"
                     || stem.ends_with("-gcc")
                     || stem == "g++"
                     || stem.ends_with("-g++")
                     || stem == "clang"
+                    || stem.ends_with("-clang")
                     || stem == "clang++"
+                    || stem.ends_with("-clang++")
                 {
                     LinkerFlavor::from_cli(LinkerFlavorCli::Gcc, &sess.target)
                 } else if stem == "wasm-ld" || stem.ends_with("-wasm-ld") {

diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -256,11 +256,17 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                                     {
                                         let rhs_pos =
                                             span.lo() + BytePos::from_usize(eq_idx + 2 + rhs_idx);
-                                        let rhs_span = span.with_lo(rhs_pos).with_hi(rhs_pos);
+                                        let rhs_span = tcx
+                                            .mark_span_for_resize(span)
+                                            .with_lo(rhs_pos)
+                                            .with_hi(rhs_pos);
                                         err.multipart_suggestion(
                                             "consider dereferencing here",
                                             vec![
-                                                (span.shrink_to_lo(), deref.clone()),
+                                                (
+                                                    tcx.mark_span_for_resize(span).shrink_to_lo(),
+                                                    deref.clone(),
+                                                ),
                                                 (rhs_span, deref),
                                             ],
                                             Applicability::MachineApplicable,

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
@@ -621,6 +621,10 @@ impl Diagnostic {
             .map(|(span, snippet)| SubstitutionPart { snippet, span })
             .collect::<Vec<_>>();
 
+        if !parts.iter().all(|sub| sub.span.can_be_used_for_suggestions()) {
+            return self;
+        }
+
         parts.sort_unstable_by_key(|part| part.span);
 
         assert!(!parts.is_empty());
@@ -711,6 +715,9 @@ impl Diagnostic {
             !(sp.is_empty() && suggestion.to_string().is_empty()),
             "Span must not be empty and have no suggestion"
         );
+        if !sp.can_be_used_for_suggestions() {
+            return self;
+        }
         self.push_suggestion(CodeSuggestion {
             substitutions: vec![Substitution {
                 parts: vec![SubstitutionPart { snippet: suggestion.to_string(), span: sp }],
@@ -774,6 +781,9 @@ impl Diagnostic {
             !(sp.is_empty() && suggestions.iter().any(|suggestion| suggestion.is_empty())),
             "Span must not be empty and have no suggestion"
         );
+        if !sp.can_be_used_for_suggestions() {
+            return self;
+        }
 
         let substitutions = suggestions
             .into_iter()
@@ -799,12 +809,16 @@ impl Diagnostic {
     ) -> &mut Self {
         let substitutions = suggestions
             .into_iter()
-            .map(|sugg| {
+            .filter_map(|sugg| {
                 let mut parts = sugg
                     .into_iter()
                     .map(|(span, snippet)| SubstitutionPart { snippet, span })
                     .collect::<Vec<_>>();
 
+                if !parts.iter().all(|sub| sub.span.can_be_used_for_suggestions()) {
+                    return None;
+                }
+
                 parts.sort_unstable_by_key(|part| part.span);
 
                 assert!(!parts.is_empty());
@@ -819,7 +833,7 @@ impl Diagnostic {
                     "suggestion must not have overlapping parts",
                 );
 
-                Substitution { parts }
+                Some(Substitution { parts })
             })
             .collect();
 

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
@@ -10,7 +10,7 @@
 use Destination::*;
 
 use rustc_span::source_map::SourceMap;
-use rustc_span::{FileLines, SourceFile, Span};
+use rustc_span::{DesugaringKind, FileLines, SourceFile, Span};
 
 use crate::snippet::{Annotation, AnnotationType, Line, MultilineAnnotation, Style, StyledString};
 use crate::styled_buffer::StyledBuffer;
@@ -400,12 +400,13 @@ pub trait Emitter: Translate {
             // entries we don't want to print, to make sure the indices being
             // printed are contiguous (or omitted if there's only one entry).
             let macro_backtrace: Vec<_> = sp.macro_backtrace().collect();
-            for (i, trace) in macro_backtrace.iter().rev().enumerate() {
-                if trace.def_site.is_dummy() {
-                    continue;
-                }
-
-                if always_backtrace && !matches!(trace.kind, ExpnKind::Inlined) {
+            for (i, trace) in macro_backtrace.iter().rev().enumerate().filter(|(_, trace)| {
+                !matches!(
+                    trace.kind,
+                    ExpnKind::Inlined | ExpnKind::Desugaring(DesugaringKind::Resize)
+                ) && !trace.def_site.is_dummy()
+            }) {
+                if always_backtrace {
                     new_labels.push((
                         trace.def_site,
                         format!(

diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -1673,7 +1673,6 @@ pub struct Expr<'hir> {
 impl Expr<'_> {
     pub fn precedence(&self) -> ExprPrecedence {
         match self.kind {
-            ExprKind::Box(_) => ExprPrecedence::Box,
             ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
             ExprKind::Array(_) => ExprPrecedence::Array,
             ExprKind::Call(..) => ExprPrecedence::Call,
@@ -1763,7 +1762,6 @@ impl Expr<'_> {
             | ExprKind::Lit(_)
             | ExprKind::ConstBlock(..)
             | ExprKind::Unary(..)
-            | ExprKind::Box(..)
             | ExprKind::AddrOf(..)
             | ExprKind::Binary(..)
             | ExprKind::Yield(..)
@@ -1851,7 +1849,6 @@ impl Expr<'_> {
             | ExprKind::InlineAsm(..)
             | ExprKind::AssignOp(..)
             | ExprKind::ConstBlock(..)
-            | ExprKind::Box(..)
             | ExprKind::Binary(..)
             | ExprKind::Yield(..)
             | ExprKind::DropTemps(..)
@@ -1862,8 +1859,7 @@ impl Expr<'_> {
     /// To a first-order approximation, is this a pattern?
     pub fn is_approximately_pattern(&self) -> bool {
         match &self.kind {
-            ExprKind::Box(_)
-            | ExprKind::Array(_)
+            ExprKind::Array(_)
             | ExprKind::Call(..)
             | ExprKind::Tup(_)
             | ExprKind::Lit(_)
@@ -1910,8 +1906,6 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
 
 #[derive(Debug, HashStable_Generic)]
 pub enum ExprKind<'hir> {
-    /// A `box x` expression.
-    Box(&'hir Expr<'hir>),
     /// Allow anonymous constants from an inline `const` block
     ConstBlock(AnonConst),
     /// An array (e.g., `[a, b, c, d]`).

diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -682,7 +682,6 @@ pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonCo
 pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>) {
     visitor.visit_id(expression.hir_id);
     match expression.kind {
-        ExprKind::Box(ref subexpression) => visitor.visit_expr(subexpression),
         ExprKind::Array(subexpressions) => {
             walk_list!(visitor, visit_expr, subexpressions);
         }

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -557,7 +557,7 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
             check_opaque(tcx, id);
         }
         DefKind::ImplTraitPlaceholder => {
-            let parent = tcx.impl_trait_in_trait_parent(id.owner_id.to_def_id());
+            let parent = tcx.impl_trait_in_trait_parent_fn(id.owner_id.to_def_id());
             // Only check the validity of this opaque type if the function has a default body
             if let hir::Node::TraitItem(hir::TraitItem {
                 kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1351,7 +1351,8 @@ fn compare_number_of_method_arguments<'tcx>(
                     if pos == 0 {
                         arg.span
                     } else {
-                        arg.span.with_lo(trait_m_sig.decl.inputs[0].span.lo())
+                        tcx.mark_span_for_resize(arg.span)
+                            .with_lo(trait_m_sig.decl.inputs[0].span.lo())
                     }
                 })
             })
@@ -1367,7 +1368,7 @@ fn compare_number_of_method_arguments<'tcx>(
                 if pos == 0 {
                     arg.span
                 } else {
-                    arg.span.with_lo(impl_m_sig.decl.inputs[0].span.lo())
+                    tcx.mark_span_for_resize(arg.span).with_lo(impl_m_sig.decl.inputs[0].span.lo())
                 }
             })
             .unwrap_or_else(|| tcx.def_span(impl_m.def_id));
@@ -1464,7 +1465,9 @@ fn compare_synthetic_generics<'tcx>(
 
                         // in case there are no generics, take the spot between the function name
                         // and the opening paren of the argument list
-                        let new_generics_span = tcx.def_ident_span(impl_def_id)?.shrink_to_hi();
+                        let new_generics_span = tcx
+                            .mark_span_for_resize(tcx.def_ident_span(impl_def_id)?)
+                            .shrink_to_hi();
                         // in case there are generics, just replace them
                         let generics_span =
                             impl_m.generics.span.substitute_dummy(new_generics_span);

diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -220,7 +220,7 @@ fn missing_items_err(
     let hi = full_impl_span.hi() - BytePos(1);
     // Point at the place right before the closing brace of the relevant `impl` to suggest
     // adding the associated item at the end of its body.
-    let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
+    let sugg_sp = tcx.mark_span_for_resize(full_impl_span).with_lo(hi).with_hi(hi);
     // Obtain the level of indentation ending in `sugg_sp`.
     let padding =
         tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(|| String::new());