Handle existing parentheses when suggesting trailing-tuple-comma

Author: bobrippling

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

@@ -2045,14 +2045,27 @@ 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 expected.tuple_fields().count() == 1 => {
-                            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,
-                            );
+                            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,
+                                    );
+                                }
+                            }
                         }
                         // 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