Rollup merge of #114549 - chenyukang:yukang-review-resolve-part, r=petrochenkov

Style fix and refactor on resolve diagnostics

- coding style
- refactor api of `span_look_ahead`

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -555,7 +555,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
                 }
             })
             .collect::<Vec<_>>();
-        let crate_def_id = CRATE_DEF_ID.to_def_id();
         // Try to filter out intrinsics candidates, as long as we have
         // some other candidates to suggest.
         let intrinsic_candidates: Vec<_> = candidates
@@ -566,8 +565,9 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
             .collect();
         if candidates.is_empty() {
             // Put them back if we have no more candidates to suggest...
-            candidates.extend(intrinsic_candidates);
+            candidates = intrinsic_candidates;
         }
+        let crate_def_id = CRATE_DEF_ID.to_def_id();
         if candidates.is_empty() && is_expected(Res::Def(DefKind::Enum, crate_def_id)) {
             let mut enum_candidates: Vec<_> = self
                 .r
@@ -1180,9 +1180,9 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
     /// return the span of whole call and the span for all arguments expect the first one (`self`).
     fn call_has_self_arg(&self, source: PathSource<'_>) -> Option<(Span, Option<Span>)> {
         let mut has_self_arg = None;
-        if let PathSource::Expr(Some(parent)) = source {
+        if let PathSource::Expr(Some(parent)) = source
-            match &parent.kind {
+            && let ExprKind::Call(_, args) = &parent.kind
-                ExprKind::Call(_, args) if !args.is_empty() => {
+            && !args.is_empty() {
                 let mut expr_kind = &args[0].kind;
                 loop {
                     match expr_kind {
@@ -1208,9 +1208,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
                     }
                 }
         }
-                _ => (),
-            }
-        };
         has_self_arg
     }
 
@@ -1220,15 +1217,15 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
         // where a brace being opened means a block is being started. Look
         // ahead for the next text to see if `span` is followed by a `{`.
         let sm = self.r.tcx.sess.source_map();
-        let sp = sm.span_look_ahead(span, None, Some(50));
+        if let Some(followed_brace_span) = sm.span_look_ahead(span, "{", Some(50)) {
-        let followed_by_brace = matches!(sm.span_to_snippet(sp), Ok(ref snippet) if snippet == "{");
             // In case this could be a struct literal that needs to be surrounded
             // by parentheses, find the appropriate span.
-        let closing_span = sm.span_look_ahead(span, Some("}"), Some(50));
+            let close_brace_span = sm.span_look_ahead(followed_brace_span, "}", Some(50));
-        let closing_brace: Option<Span> = sm
+            let closing_brace = close_brace_span.map(|sp| span.to(sp));
-            .span_to_snippet(closing_span)
+            (true, closing_brace)
-            .map_or(None, |s| if s == "}" { Some(span.to(closing_span)) } else { None });
+        } else {
-        (followed_by_brace, closing_brace)
+            (false, None)
+        }
     }
 
     /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment`

compiler/rustc_span/src/source_map.rs

@@ -973,24 +973,21 @@ impl SourceMap {
         Span::new(BytePos(start_of_next_point), end_of_next_point, sp.ctxt(), None)
     }
 
-    /// Returns a new span to check next none-whitespace character or some specified expected character
+    /// Check whether span is followed by some specified expected string in limit scope
-    /// If `expect` is none, the first span of non-whitespace character is returned.
+    pub fn span_look_ahead(&self, span: Span, expect: &str, limit: Option<usize>) -> Option<Span> {
-    /// If `expect` presented, the first span of the character `expect` is returned
-    /// Otherwise, the span reached to limit is returned.
-    pub fn span_look_ahead(&self, span: Span, expect: Option<&str>, limit: Option<usize>) -> Span {
         let mut sp = span;
         for _ in 0..limit.unwrap_or(100_usize) {
             sp = self.next_point(sp);
             if let Ok(ref snippet) = self.span_to_snippet(sp) {
-                if expect.is_some_and(|es| snippet == es) {
+                if snippet == expect {
-                    break;
+                    return Some(sp);
                 }
-                if expect.is_none() && snippet.chars().any(|c| !c.is_whitespace()) {
+                if snippet.chars().any(|c| !c.is_whitespace()) {
                     break;
                 }
             }
         }
-        sp
+        None
     }
 
     /// Finds the width of the character, either before or after the end of provided span,

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

@@ -1429,10 +1429,9 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
 
                         // Issue #109436, we need to add parentheses properly for method calls
                         // for example, `foo.into()` should be `(&foo).into()`
-                        if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(
+                        if let Some(_) =
-                            self.tcx.sess.source_map().span_look_ahead(span, Some("."), Some(50)),
+                            self.tcx.sess.source_map().span_look_ahead(span, ".", Some(50))
-                        ) {
+                        {
-                            if snippet == "." {
                             err.multipart_suggestion_verbose(
                                 sugg_msg,
                                 vec![
@@ -1443,7 +1442,6 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                             );
                             return true;
                         }
-                        }
 
                         // Issue #104961, we need to add parentheses properly for compound expressions
                         // for example, `x.starts_with("hi".to_string() + "you")`