Suggest add bounding value for RangeTo

Author: chenyukang

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1732,6 +1732,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         self.note_derefed_ty_has_method(&mut err, source, rcvr_ty, item_ident, expected);
+        self.suggest_bounds_for_range_to_method(&mut err, source, item_ident);
         err.emit()
     }
 
@@ -3228,6 +3229,61 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    fn suggest_bounds_for_range_to_method(
+        &self,
+        err: &mut Diag<'_>,
+        source: SelfSource<'tcx>,
+        item_ident: Ident,
+    ) {
+        if let SelfSource::MethodCall(rcvr_expr) = source
+            && let hir::ExprKind::Struct(qpath, _, _) = rcvr_expr.kind
+            && let hir::QPath::LangItem(lang_item, _) = qpath
+        {
+            let is_inclusive = match lang_item {
+                hir::LangItem::RangeTo => false,
+                hir::LangItem::RangeToInclusive => true,
+                _ => return,
+            };
+
+            // Check if the method exists on Iterator trait
+            let tcx = self.tcx;
+            if let Some(iterator_trait) = tcx.get_diagnostic_item(sym::Iterator) {
+                let has_method = tcx
+                    .associated_items(iterator_trait)
+                    .filter_by_name_unhygienic(item_ident.name)
+                    .next()
+                    .is_some();
+
+                if !has_method {
+                    return;
+                }
+            }
+
+            let range_type = if is_inclusive { "RangeInclusive" } else { "Range" };
+            let source_map = self.tcx.sess.source_map();
+
+            if let Ok(snippet) = source_map.span_to_snippet(rcvr_expr.span) {
+                let offset = snippet
+                    .chars()
+                    .take_while(|&c| c == '(' || c.is_whitespace())
+                    .map(|c| c.len_utf8())
+                    .sum::<usize>();
+
+                let insert_span = rcvr_expr
+                    .span
+                    .with_lo(rcvr_expr.span.lo() + rustc_span::BytePos(offset as u32))
+                    .shrink_to_lo();
+
+                err.span_suggestion_verbose(
+                    insert_span,
+                    format!("consider using a bounded `{range_type}` by adding a starting value"),
+                    "0",
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+
     /// Print out the type for use in value namespace.
     fn ty_to_value_string(&self, ty: Ty<'tcx>) -> String {
         match ty.kind() {

tests/ui/range/range-to-iterator-suggestion-issue-147749.rs

@@ -0,0 +1,17 @@
+fn main() {
+    for x in (..4).rev() {
+        //~^ ERROR `RangeTo<{integer}>` is not an iterator
+        //~| HELP consider using a bounded `Range` by adding a starting value
+        let _ = x;
+    }
+
+    for x in (..=4).rev() {
+        //~^ ERROR `std::ops::RangeToInclusive<{integer}>` is not an iterator
+        //~| HELP consider using a bounded `RangeInclusive` by adding a starting value
+        let _ = x;
+    }
+
+    // should not suggest for `iter` method
+    let _v: Vec<_> = (..5).iter().collect();
+    //~^ ERROR no method named `iter` found
+}

tests/ui/range/range-to-iterator-suggestion-issue-147749.stderr

@@ -0,0 +1,39 @@
+error[E0599]: `RangeTo<{integer}>` is not an iterator
+  --> $DIR/range-to-iterator-suggestion-issue-147749.rs:2:20
+   |
+LL |     for x in (..4).rev() {
+   |                    ^^^ `RangeTo<{integer}>` is not an iterator
+   |
+   = note: the following trait bounds were not satisfied:
+           `RangeTo<{integer}>: Iterator`
+           which is required by `&mut RangeTo<{integer}>: Iterator`
+   = note: you might have meant to use a bounded `Range`
+help: consider using a bounded `Range` by adding a starting value
+   |
+LL |     for x in (0..4).rev() {
+   |               +
+
+error[E0599]: `std::ops::RangeToInclusive<{integer}>` is not an iterator
+  --> $DIR/range-to-iterator-suggestion-issue-147749.rs:8:21
+   |
+LL |     for x in (..=4).rev() {
+   |                     ^^^ `std::ops::RangeToInclusive<{integer}>` is not an iterator
+   |
+   = note: the following trait bounds were not satisfied:
+           `std::ops::RangeToInclusive<{integer}>: Iterator`
+           which is required by `&mut std::ops::RangeToInclusive<{integer}>: Iterator`
+   = note: you might have meant to use a bounded `RangeInclusive`
+help: consider using a bounded `RangeInclusive` by adding a starting value
+   |
+LL |     for x in (0..=4).rev() {
+   |               +
+
+error[E0599]: no method named `iter` found for struct `RangeTo<Idx>` in the current scope
+  --> $DIR/range-to-iterator-suggestion-issue-147749.rs:15:28
+   |
+LL |     let _v: Vec<_> = (..5).iter().collect();
+   |                            ^^^^ method not found in `RangeTo<{integer}>`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0599`.