Suggest Semicolon in Incorrect Repeat Expressions

veera-sivarajan · veera-sivarajan · commit d9825636662c · 2024-10-15T16:44:30.000Z
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::{
     self as ast, Attribute, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece, IntTy, Label,
-    LitKind, TraitObjectSyntax, UintTy,
+    LitIntType, LitKind, TraitObjectSyntax, UintTy,
 };
 pub use rustc_ast::{
     BinOp, BinOpKind, BindingMode, BorrowKind, ByRef, CaptureBy, ImplPolarity, IsAuto, Movability,
@@ -1828,6 +1828,18 @@ impl Expr<'_> {
         }
     }
 
+    /// Check if expression is an integer literal that can be used
+    /// where `usize` is expected.
+    pub fn is_size_lit(&self) -> bool {
+        matches!(
+            self.kind,
+            ExprKind::Lit(Lit {
+                node: LitKind::Int(_, LitIntType::Unsuffixed | LitIntType::Unsigned(UintTy::Usize)),
+                ..
+            })
+        )
+    }
+
     /// If `Self.kind` is `ExprKind::DropTemps(expr)`, drill down until we get a non-`DropTemps`
     /// `Expr`. This is used in suggestions to ignore this `ExprKind` as it is semantically
     /// silent, only signaling the ownership system. By doing this, suggestions that check the
diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
@@ -155,6 +155,8 @@ hir_typeck_remove_semi_for_coerce_ret = the `match` arms can conform to this ret
 hir_typeck_remove_semi_for_coerce_semi = the `match` is a statement because of this semicolon, consider removing it
 hir_typeck_remove_semi_for_coerce_suggestion = remove this semicolon
 
+hir_typeck_replace_comma_with_semicolon = replace the comma with a semicolon to create {$descr}
+
 hir_typeck_return_stmt_outside_of_fn_body =
     {$statement_kind} statement outside of function body
     .encl_body_label = the {$statement_kind} is part of this body...
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
@@ -31,7 +31,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if expr_ty == expected {
             return;
         }
-
         self.annotate_alternative_method_deref(err, expr, error);
         self.explain_self_literal(err, expr, expected, expr_ty);
 
@@ -40,6 +39,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty)
             || self.suggest_remove_last_method_call(err, expr, expected)
             || self.suggest_associated_const(err, expr, expected)
+            || self.suggest_semicolon_in_repeat_expr(err, expr, expr_ty)
             || self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr)
             || self.suggest_option_to_bool(err, expr, expr_ty, expected)
             || self.suggest_compatible_variants(err, expr, expected, expr_ty)
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
@@ -724,3 +724,16 @@ pub(crate) struct PassToVariadicFunction<'a, 'tcx> {
     #[note(hir_typeck_teach_help)]
     pub(crate) teach: bool,
 }
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    hir_typeck_replace_comma_with_semicolon,
+    applicability = "machine-applicable",
+    style = "verbose",
+    code = "; "
+)]
+pub(crate) struct ReplaceCommaWithSemicolon {
+    #[primary_span]
+    pub comma_span: Span,
+    pub descr: &'static str,
+}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1321,14 +1321,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let span = expr.span.shrink_to_hi();
                 let subdiag = if self.type_is_copy_modulo_regions(self.param_env, ty) {
                     errors::OptionResultRefMismatch::Copied { span, def_path }
-                } else if let Some(clone_did) = self.tcx.lang_items().clone_trait()
-                    && rustc_trait_selection::traits::type_known_to_meet_bound_modulo_regions(
-                        self,
-                        self.param_env,
-                        ty,
-                        clone_did,
-                    )
-                {
+                } else if self.type_is_clone_modulo_regions(self.param_env, ty) {
                     errors::OptionResultRefMismatch::Cloned { span, def_path }
                 } else {
                     return false;
@@ -2183,6 +2176,79 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    /// Suggest replacing comma with semicolon in incorrect repeat expressions
+    /// like `["_", 10]` or `vec![String::new(), 10]`.
+    pub(crate) fn suggest_semicolon_in_repeat_expr(
+        &self,
+        err: &mut Diag<'_>,
+        expr: &hir::Expr<'_>,
+        expr_ty: Ty<'tcx>,
+    ) -> bool {
+        // Check if `expr` is contained in array of two elements
+        if let hir::Node::Expr(array_expr) = self.tcx.parent_hir_node(expr.hir_id)
+            && let hir::ExprKind::Array(elements) = array_expr.kind
+            && let [first, second] = &elements[..]
+            && second.hir_id == expr.hir_id
+        {
+            // Span between the two elements of the array
+            let comma_span = first.span.between(second.span);
+
+            // Check if `expr` is a constant value of type `usize`.
+            // This can only detect const variable declarations and
+            // calls to const functions.
+
+            // Checking this here instead of rustc_hir::hir because
+            // this check needs access to `self.tcx` but rustc_hir
+            // has no access to `TyCtxt`.
+            let expr_is_const_usize = expr_ty.is_usize()
+                && match expr.kind {
+                    ExprKind::Path(QPath::Resolved(
+                        None,
+                        Path { res: Res::Def(DefKind::Const, _), .. },
+                    )) => true,
+                    ExprKind::Call(
+                        Expr {
+                            kind:
+                                ExprKind::Path(QPath::Resolved(
+                                    None,
+                                    Path { res: Res::Def(DefKind::Fn, fn_def_id), .. },
+                                )),
+                            ..
+                        },
+                        _,
+                    ) => self.tcx.is_const_fn(*fn_def_id),
+                    _ => false,
+                };
+
+            // `array_expr` is from a macro `vec!["a", 10]` if
+            // 1. array expression's span is imported from a macro
+            // 2. first element of array implements `Clone` trait
+            // 3. second element is an integer literal or is an expression of `usize` like type
+            if self.tcx.sess.source_map().is_imported(array_expr.span)
+                && self.type_is_clone_modulo_regions(self.param_env, self.check_expr(first))
+                && (second.is_size_lit() || expr_ty.is_usize_like())
+            {
+                err.subdiagnostic(errors::ReplaceCommaWithSemicolon {
+                    comma_span,
+                    descr: "a vector",
+                });
+                return true;
+            } else if self.type_is_copy_modulo_regions(self.param_env, self.check_expr(first))
+                && (second.is_size_lit() || expr_is_const_usize)
+            {
+                // `array_expr` is from an array `["a", 10]` if
+                // 1. first element of array implements `Copy` trait
+                // 2. second element is an integer literal or is a const value of type `usize`
+                err.subdiagnostic(errors::ReplaceCommaWithSemicolon {
+                    comma_span,
+                    descr: "an array",
+                });
+                return true;
+            }
+        }
+        false
+    }
+
     /// If the expected type is an enum (Issue #55250) with any variants whose
     /// sole field is of the found type, suggest such variants. (Issue #42764)
     pub(crate) fn suggest_compatible_variants(
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -29,7 +29,7 @@ use crate::infer::canonical::Canonical;
 use crate::ty::InferTy::*;
 use crate::ty::{
     self, AdtDef, BoundRegionKind, Discr, GenericArg, GenericArgs, GenericArgsRef, List, ParamEnv,
-    Region, Ty, TyCtxt, TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitor,
+    Region, Ty, TyCtxt, TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy,
 };
 
 // Re-export and re-parameterize some `I = TyCtxt<'tcx>` types here
@@ -1005,6 +1005,18 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    /// Check if type is an `usize`.
+    #[inline]
+    pub fn is_usize(self) -> bool {
+        matches!(self.kind(), Uint(UintTy::Usize))
+    }
+
+    /// Check if type is an `usize` or an integral type variable.
+    #[inline]
+    pub fn is_usize_like(self) -> bool {
+        matches!(self.kind(), Uint(UintTy::Usize) | Infer(IntVar(_)))
+    }
+
     #[inline]
     pub fn is_never(self) -> bool {
         matches!(self.kind(), Never)
diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
@@ -43,6 +43,12 @@ impl<'tcx> InferCtxt<'tcx> {
         traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, copy_def_id)
     }
 
+    fn type_is_clone_modulo_regions(&self, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
+        let ty = self.resolve_vars_if_possible(ty);
+        let clone_def_id = self.tcx.require_lang_item(LangItem::Clone, None);
+        traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, clone_def_id)
+    }
+
     fn type_is_sized_modulo_regions(&self, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
         let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
         traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, lang_item)
diff --git a/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.rs b/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.rs
@@ -14,12 +14,12 @@ fn get_dyn_size() -> usize {
 fn main() {
     let a = ["a", 10];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create an array
+    //~| HELP replace the comma with a semicolon to create an array
 
     const size_b: usize = 20;
     let b = [Type, size_b];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create an array
+    //~| HELP replace the comma with a semicolon to create an array
 
     let size_c: usize = 13;
     let c = [Type, size_c];
@@ -35,28 +35,28 @@ fn main() {
 
     let f = ["f", get_size()];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create an array
+    //~| HELP replace the comma with a semicolon to create an array
 
     let m = ["m", get_dyn_size()];
     //~^ ERROR mismatched types
 
     // is_vec, is_clone, is_usize_like
     let g = vec![String::new(), 10];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create a vector
+    //~| HELP replace the comma with a semicolon to create a vector
 
     let dyn_size = 10;
     let h = vec![Type, dyn_size];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create a vector
+    //~| HELP replace the comma with a semicolon to create a vector
 
     let i = vec![Type, get_dyn_size()];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create a vector
+    //~| HELP replace the comma with a semicolon to create a vector
 
     let k = vec!['c', 10];
     //~^ ERROR mismatched types
-    //~| HELP replace comma with semicolon to create a vector
+    //~| HELP replace the comma with a semicolon to create a vector
 
     let j = vec![Type, 10_u8];
     //~^ ERROR mismatched types
diff --git a/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr b/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr
@@ -4,7 +4,7 @@ error[E0308]: mismatched types
 LL |     let a = ["a", 10];
    |                   ^^ expected `&str`, found integer
    |
-help: replace comma with semicolon to create an array
+help: replace the comma with a semicolon to create an array
    |
 LL |     let a = ["a"; 10];
    |                 ~
@@ -15,7 +15,7 @@ error[E0308]: mismatched types
 LL |     let b = [Type, size_b];
    |                    ^^^^^^ expected `Type`, found `usize`
    |
-help: replace comma with semicolon to create an array
+help: replace the comma with a semicolon to create an array
    |
 LL |     let b = [Type; size_b];
    |                  ~
@@ -46,7 +46,7 @@ error[E0308]: mismatched types
 LL |     let f = ["f", get_size()];
    |                   ^^^^^^^^^^ expected `&str`, found `usize`
    |
-help: replace comma with semicolon to create an array
+help: replace the comma with a semicolon to create an array
    |
 LL |     let f = ["f"; get_size()];
    |                 ~
@@ -63,7 +63,7 @@ error[E0308]: mismatched types
 LL |     let g = vec![String::new(), 10];
    |                                 ^^ expected `String`, found integer
    |
-help: replace comma with semicolon to create a vector
+help: replace the comma with a semicolon to create a vector
    |
 LL |     let g = vec![String::new(); 10];
    |                               ~
@@ -74,7 +74,7 @@ error[E0308]: mismatched types
 LL |     let h = vec![Type, dyn_size];
    |                        ^^^^^^^^ expected `Type`, found integer
    |
-help: replace comma with semicolon to create a vector
+help: replace the comma with a semicolon to create a vector
    |
 LL |     let h = vec![Type; dyn_size];
    |                      ~
@@ -85,7 +85,7 @@ error[E0308]: mismatched types
 LL |     let i = vec![Type, get_dyn_size()];
    |                        ^^^^^^^^^^^^^^ expected `Type`, found `usize`
    |
-help: replace comma with semicolon to create a vector
+help: replace the comma with a semicolon to create a vector
    |
 LL |     let i = vec![Type; get_dyn_size()];
    |                      ~
@@ -96,7 +96,7 @@ error[E0308]: mismatched types
 LL |     let k = vec!['c', 10];
    |                       ^^ expected `char`, found `u8`
    |
-help: replace comma with semicolon to create a vector
+help: replace the comma with a semicolon to create a vector
    |
 LL |     let k = vec!['c'; 10];
    |                     ~

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ error[E0308]: mismatched types`
`4`	`4`	`LL \| let a = ["a", 10];`
`5`	`5`	\| ^^ expected `&str`, found integer
`6`	`6`	`\|`
`7`		`-help: replace comma with semicolon to create an array`
	`7`	`+help: replace the comma with a semicolon to create an array`
`8`	`8`	`\|`
`9`	`9`	`LL \| let a = ["a"; 10];`
`10`	`10`	`\| ~`
`@@ -15,7 +15,7 @@ error[E0308]: mismatched types`
`15`	`15`	`LL \| let b = [Type, size_b];`
`16`	`16`	\| ^^^^^^ expected `Type`, found `usize`
`17`	`17`	`\|`
`18`		`-help: replace comma with semicolon to create an array`
	`18`	`+help: replace the comma with a semicolon to create an array`
`19`	`19`	`\|`
`20`	`20`	`LL \| let b = [Type; size_b];`
`21`	`21`	`\| ~`
`@@ -46,7 +46,7 @@ error[E0308]: mismatched types`
`46`	`46`	`LL \| let f = ["f", get_size()];`
`47`	`47`	\| ^^^^^^^^^^ expected `&str`, found `usize`
`48`	`48`	`\|`
`49`		`-help: replace comma with semicolon to create an array`
	`49`	`+help: replace the comma with a semicolon to create an array`
`50`	`50`	`\|`
`51`	`51`	`LL \| let f = ["f"; get_size()];`
`52`	`52`	`\| ~`
`@@ -63,7 +63,7 @@ error[E0308]: mismatched types`
`63`	`63`	`LL \| let g = vec![String::new(), 10];`
`64`	`64`	\| ^^ expected `String`, found integer
`65`	`65`	`\|`
`66`		`-help: replace comma with semicolon to create a vector`
	`66`	`+help: replace the comma with a semicolon to create a vector`
`67`	`67`	`\|`
`68`	`68`	`LL \| let g = vec![String::new(); 10];`
`69`	`69`	`\| ~`
`@@ -74,7 +74,7 @@ error[E0308]: mismatched types`
`74`	`74`	`LL \| let h = vec![Type, dyn_size];`
`75`	`75`	\| ^^^^^^^^ expected `Type`, found integer
`76`	`76`	`\|`
`77`		`-help: replace comma with semicolon to create a vector`
	`77`	`+help: replace the comma with a semicolon to create a vector`
`78`	`78`	`\|`
`79`	`79`	`LL \| let h = vec![Type; dyn_size];`
`80`	`80`	`\| ~`
`@@ -85,7 +85,7 @@ error[E0308]: mismatched types`
`85`	`85`	`LL \| let i = vec![Type, get_dyn_size()];`
`86`	`86`	\| ^^^^^^^^^^^^^^ expected `Type`, found `usize`
`87`	`87`	`\|`
`88`		`-help: replace comma with semicolon to create a vector`
	`88`	`+help: replace the comma with a semicolon to create a vector`
`89`	`89`	`\|`
`90`	`90`	`LL \| let i = vec![Type; get_dyn_size()];`
`91`	`91`	`\| ~`
`@@ -96,7 +96,7 @@ error[E0308]: mismatched types`
`96`	`96`	`LL \| let k = vec!['c', 10];`
`97`	`97`	\| ^^ expected `char`, found `u8`
`98`	`98`	`\|`
`99`		`-help: replace comma with semicolon to create a vector`
	`99`	`+help: replace the comma with a semicolon to create a vector`
`100`	`100`	`\|`
`101`	`101`	`LL \| let k = vec!['c'; 10];`
`102`	`102`	`\| ~`