Factor out emit_tuple_wrap_err, improve Applicability

Author: bobrippling

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -2045,35 +2045,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                         // parentheses around it, perhaps the user meant to write `(expr,)` to
                         // build a tuple (issue #86100)
                         (ty::Tuple(_), _) => {
-                            if let [expected_tup_elem] =
-                                expected.tuple_fields().collect::<Vec<_>>()[..]
-                            {
-                                if same_type_modulo_infer(expected_tup_elem, found) {
-                                    if let Ok(code) =
-                                        self.tcx.sess().source_map().span_to_snippet(span)
-                                    {
-                                        if code.starts_with('(') && code.ends_with(')') {
-                                            let before_close = span.hi() - BytePos::from_u32(1);
-
-                                            err.span_suggestion(
-                                                span.with_hi(before_close).shrink_to_hi(),
-                                                "use a trailing comma to create a tuple with one element",
-                                                ",".into(),
-                                                Applicability::MaybeIncorrect,
-                                            );
-                                        } else {
-                                            err.multipart_suggestion(
-                                                "use a trailing comma to create a tuple with one element",
-                                                vec![
-                                                    (span.shrink_to_lo(), "(".into()),
-                                                    (span.shrink_to_hi(), ",)".into()),
-                                                ],
-                                                Applicability::MaybeIncorrect,
-                                            );
-                                        }
-                                    }
-                                }
-                            }
+                            self.emit_tuple_wrap_err(&mut err, span, found, expected)
                         }
                         // If a character was expected and the found expression is a string literal
                         // containing a single character, perhaps the user meant to write `'c'` to
@@ -2136,6 +2108,44 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         diag
     }
 
+    fn emit_tuple_wrap_err(
+        &self,
+        err: &mut DiagnosticBuilder<'tcx>,
+        span: Span,
+        found: Ty<'tcx>,
+        expected: Ty<'tcx>,
+    ) {
+        let [expected_tup_elem] = &expected.tuple_fields().collect::<Vec<_>>()[..]
+            else { return };
+
+        if !same_type_modulo_infer(expected_tup_elem, found) {
+            return;
+        }
+
+        let Ok(code) = self.tcx.sess().source_map().span_to_snippet(span)
+            else { return };
+
+        if code.starts_with('(') && code.ends_with(')') {
+            let before_close = span.hi() - BytePos::from_u32(1);
+
+            err.span_suggestion(
+                span.with_hi(before_close).shrink_to_hi(),
+                "use a trailing comma to create a tuple with one element",
+                ",".into(),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            err.multipart_suggestion(
+                "use a trailing comma to create a tuple with one element",
+                vec![
+                    (span.shrink_to_lo(), "(".into()),
+                    (span.shrink_to_hi(), ",)".into()),
+                ],
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+
     fn values_str(
         &self,
         values: ValuePairs<'tcx>,