Auto merge of #146069 - camsteffen:range-desugar-span, r=SparrowLii

Mark desugared range expression spans with DesugaringKind::RangeExpr This is a prerequisite to removing `QPath::LangItem` (#115178) because otherwise there would be no way to detect a range expression in the HIR. There are some non-obvious Clippy changes so a Clippy team review would be good.

Author: bors

compiler/rustc_ast_lowering/src/expr.rs

@@ -63,13 +63,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
  pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
  ensure_sufficient_stack(|| {
+ let mut span = self.lower_span(e.span);
  match &e.kind {
  // Parenthesis expression does not have a HirId and is handled specially.
  ExprKind::Paren(ex) => {
  let mut ex = self.lower_expr_mut(ex);
  // Include parens in span, but only if it is a super-span.
  if e.span.contains(ex.span) {
- ex.span = self.lower_span(e.span);
+ ex.span = self.lower_span(e.span.with_ctxt(ex.span.ctxt()));
  }
  // Merge attributes into the inner expression.
  if !e.attrs.is_empty() {
@@ -288,7 +289,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
  self.lower_span(*brackets_span),
  ),
  ExprKind::Range(e1, e2, lims) => {
- self.lower_expr_range(e.span, e1.as_deref(), e2.as_deref(), *lims)
+ span = self.mark_span_with_reason(DesugaringKind::RangeExpr, span, None);
+ self.lower_expr_range(span, e1.as_deref(), e2.as_deref(), *lims)
  }
  ExprKind::Underscore => {
  let guar = self.dcx().emit_err(UnderscoreExprLhsAssign { span: e.span });
@@ -380,7 +382,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
  };
 
- hir::Expr { hir_id: expr_hir_id, kind, span: self.lower_span(e.span) }
+ hir::Expr { hir_id: expr_hir_id, kind, span }
  })
  }
 
@@ -1482,7 +1484,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  fn lower_expr_range_closed(&mut self, span: Span, e1: &Expr, e2: &Expr) -> hir::ExprKind<'hir> {
  let e1 = self.lower_expr_mut(e1);
  let e2 = self.lower_expr_mut(e2);
- let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, self.lower_span(span));
+ let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, span);
  let fn_expr = self.arena.alloc(self.expr(span, hir::ExprKind::Path(fn_path)));
  hir::ExprKind::Call(fn_expr, arena_vec![self; e1, e2])
  }
@@ -1559,14 +1561,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
  )
  }))
  .map(|(s, e)| {
+ let span = self.lower_span(e.span);
+ let span = self.mark_span_with_reason(DesugaringKind::RangeExpr, span, None);
  let expr = self.lower_expr(e);
- let ident = Ident::new(s, self.lower_span(e.span));
- self.expr_field(ident, expr, e.span)
+ let ident = Ident::new(s, span);
+ self.expr_field(ident, expr, span)
  }),
  );
 
  hir::ExprKind::Struct(
- self.arena.alloc(hir::QPath::LangItem(lang_item, self.lower_span(span))),
+ self.arena.alloc(hir::QPath::LangItem(lang_item, span)),
  fields,
  hir::StructTailExpr::None,
  )

compiler/rustc_hir/src/hir.rs

@@ -2460,6 +2460,12 @@ impl Expr<'_> {
  }
  }
 
+ /// If this is a desugared range expression,
+ /// returns the span of the range without desugaring context.
+ pub fn range_span(&self) -> Option<Span> {
+ is_range_literal(self).then(|| self.span.parent_callsite().unwrap())
+ }
+
  /// Check if expression is an integer literal that can be used
  /// where `usize` is expected.
  pub fn is_size_lit(&self) -> bool {

compiler/rustc_hir_typeck/src/expr.rs

@@ -2509,11 +2509,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .tcx
  .sess
  .source_map()
- .span_extend_while_whitespace(range_start.span)
+ .span_extend_while_whitespace(range_start.expr.span)
  .shrink_to_hi()
- .to(range_end.span);
+ .to(range_end.expr.span);
 
- err.subdiagnostic(TypeMismatchFruTypo { expr_span: range_start.span, fru_span, expr });
+ err.subdiagnostic(TypeMismatchFruTypo {
+ expr_span: range_start.expr.span,
+ fru_span,
+ expr,
+ });
 
  // Suppress any range expr type mismatches
  self.dcx().try_steal_replace_and_emit_err(

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -1666,25 +1666,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  match expr.kind {
  ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), [start, end], _) => {
  err.span_suggestion_verbose(
- start.span.shrink_to_hi().with_hi(end.span.lo()),
+ start.expr.span.shrink_to_hi().with_hi(end.expr.span.lo()),
  "remove the unnecessary `.` operator for a floating point literal",
  '.',
  Applicability::MaybeIncorrect,
  );
  true
  }
  ExprKind::Struct(QPath::LangItem(LangItem::RangeFrom, ..), [start], _) => {
+ let range_span = expr.span.parent_callsite().unwrap();
  err.span_suggestion_verbose(
- expr.span.with_lo(start.span.hi()),
+ range_span.with_lo(start.expr.span.hi()),
  "remove the unnecessary `.` operator for a floating point literal",
  '.',
  Applicability::MaybeIncorrect,
  );
  true
  }
  ExprKind::Struct(QPath::LangItem(LangItem::RangeTo, ..), [end], _) => {
+ let range_span = expr.span.parent_callsite().unwrap();
  err.span_suggestion_verbose(
- expr.span.until(end.span),
+ range_span.until(end.expr.span),
  "remove the unnecessary `.` operator and add an integer part for a floating point literal",
  "0.",
  Applicability::MaybeIncorrect,
@@ -2693,7 +2695,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  bool, /* suggest `&` or `&mut` type annotation */
  )> {
  let sess = self.sess();
- let sp = expr.span;
+ let sp = expr.range_span().unwrap_or(expr.span);
  let sm = sess.source_map();
 
  // If the span is from an external macro, there's no suggestion we can make.

compiler/rustc_lint/src/types/literal.rs

@@ -1,4 +1,4 @@
-use hir::{ExprKind, Node, is_range_literal};
+use hir::{ExprKind, Node};
 use rustc_abi::{Integer, Size};
 use rustc_hir::{HirId, attrs};
 use rustc_middle::ty::Ty;
@@ -44,7 +44,7 @@ fn lint_overflowing_range_endpoint<'tcx>(
  let Node::Expr(struct_expr) = cx.tcx.parent_hir_node(field.hir_id) else {
  return false;
  };
- if !is_range_literal(struct_expr) {
+ let Some(range_span) = struct_expr.range_span() else {
  return false;
  };
  let ExprKind::Struct(_, [start, end], _) = &struct_expr.kind else {
@@ -71,7 +71,7 @@ fn lint_overflowing_range_endpoint<'tcx>(
  return false;
  };
  UseInclusiveRange::WithoutParen {
- sugg: struct_expr.span.shrink_to_lo().to(lit_span.shrink_to_hi()),
+ sugg: range_span.shrink_to_lo().to(lit_span.shrink_to_hi()),
  start,
  literal: lit_val - 1,
  suffix,
@@ -87,7 +87,7 @@ fn lint_overflowing_range_endpoint<'tcx>(
 
  cx.emit_span_lint(
  OVERFLOWING_LITERALS,
- struct_expr.span,
+ range_span,
  RangeEndpointOutOfRange { ty, sub: sub_sugg },
  );
 

compiler/rustc_span/src/hygiene.rs

@@ -1247,6 +1247,7 @@ pub enum DesugaringKind {
  /// rewriting it.
  source: bool,
  },
+ RangeExpr,
 }
 
 impl DesugaringKind {
@@ -1268,6 +1269,7 @@ impl DesugaringKind {
  DesugaringKind::FormatLiteral { source: false } => {
  "expression that expanded into a format string literal"
  }
+ DesugaringKind::RangeExpr => "range expression",
  }
  }
 
@@ -1287,6 +1289,7 @@ impl DesugaringKind {
  DesugaringKind::Contract => value == "Contract",
  DesugaringKind::PatTyRange => value == "PatTyRange",
  DesugaringKind::FormatLiteral { .. } => value == "FormatLiteral",
+ DesugaringKind::RangeExpr => value == "RangeExpr",
  }
  }
 }

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -20,7 +20,7 @@ use rustc_hir::intravisit::{Visitor, VisitorExt};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{
  self as hir, AmbigArg, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, HirId, Node,
- expr_needs_parens, is_range_literal,
+ expr_needs_parens,
 };
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk};
 use rustc_middle::middle::privacy::Level;
@@ -668,12 +668,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  );
  }
  let derefs = "*".repeat(steps);
- let needs_parens = steps > 0
- && match expr.kind {
- hir::ExprKind::Cast(_, _) | hir::ExprKind::Binary(_, _, _) => true,
- _ if is_range_literal(expr) => true,
- _ => false,
- };
+ let needs_parens = steps > 0 && expr_needs_parens(expr);
  let mut suggestion = if needs_parens {
  vec![
  (

src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs

@@ -28,6 +28,7 @@ pub(super) fn check<'tcx>(
  start: Some(start),
  end: Some(end),
  limits,
+ span: _,
  }) = higher::Range::hir(arg)
  // the var must be a single name
  && let PatKind::Binding(_, canonical_id, _, _) = pat.kind

src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs

@@ -31,6 +31,7 @@ pub(super) fn check<'tcx>(
  start: Some(start),
  end: Some(end),
  limits: RangeLimits::HalfOpen,
+ span: _,
  }) = higher::Range::hir(arg)
  && let ExprKind::Lit(Spanned {
  node: LitKind::Int(Pu128(0), _),

src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs

@@ -30,6 +30,7 @@ pub(super) fn check<'tcx>(
  start: Some(start),
  ref end,
  limits,
+ span,
  }) = higher::Range::hir(arg)
  // the var must be a single name
  && let PatKind::Binding(_, canonical_id, ident, _) = pat.kind
@@ -149,15 +150,15 @@ pub(super) fn check<'tcx>(
  span_lint_and_then(
  cx,
  NEEDLESS_RANGE_LOOP,
- arg.span,
+ span,
  format!("the loop variable `{}` is used to index `{indexed}`", ident.name),
  |diag| {
  diag.multipart_suggestion(
  "consider using an iterator and enumerate()",
  vec![
  (pat.span, format!("({}, <item>)", ident.name)),
  (
- arg.span,
+ span,
  format!("{indexed}.{method}().enumerate(){method_1}{method_2}"),
  ),
  ],
@@ -175,12 +176,12 @@ pub(super) fn check<'tcx>(
  span_lint_and_then(
  cx,
  NEEDLESS_RANGE_LOOP,
- arg.span,
+ span,
  format!("the loop variable `{}` is only used to index `{indexed}`", ident.name),
  |diag| {
  diag.multipart_suggestion(
  "consider using an iterator",
- vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+ vec![(pat.span, "<item>".to_string()), (span, repl)],
  Applicability::HasPlaceholders,
  );
  },