debug issue

Author: chenyukang

compiler/rustc_errors/src/lib.rs

@@ -466,6 +466,7 @@ pub enum StashKey {
     /// When an invalid lifetime e.g. `'2` should be reinterpreted
     /// as a char literal in the parser
     LifetimeIsChar,
+    CallInstanceMethod,
 }
 
 fn default_track_diagnostic(_: &Diagnostic) {}

compiler/rustc_hir/src/intravisit.rs

@@ -697,6 +697,7 @@ pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath<'v>, id:
             visitor.visit_path(path, id)
         }
         QPath::TypeRelative(ref qself, ref segment) => {
+            debug!("yukang segment: {:?}", segment);
             visitor.visit_ty(qself);
             visitor.visit_path_segment(segment);
         }
@@ -711,6 +712,7 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>) {
 }
 
 pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V, segment: &'v PathSegment<'v>) {
+    debug!("yukang walk_path_segment: {:?}", segment);
     visitor.visit_ident(segment.ident);
     visitor.visit_id(segment.hir_id);
     if let Some(ref args) = segment.args {

compiler/rustc_hir_typeck/src/expr.rs

@@ -520,6 +520,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         args: &'tcx [hir::Expr<'tcx>],
     ) -> Ty<'tcx> {
         let tcx = self.tcx;
+        debug!("yukang check_expr_path: {:?}", qpath);
         let (res, opt_ty, segs) =
             self.resolve_ty_and_res_fully_qualified_call(qpath, expr.hir_id, expr.span);
         let ty = match res {

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -4,7 +4,7 @@ use crate::rvalue_scopes;
 use crate::{BreakableCtxt, Diverges, Expectation, FnCtxt, LocalTy};
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{Applicability, Diagnostic, ErrorGuaranteed, MultiSpan};
+use rustc_errors::{Applicability, Diagnostic, ErrorGuaranteed, MultiSpan, StashKey};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -863,6 +863,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
         let (ty, qself, item_segment) = match *qpath {
             QPath::Resolved(ref opt_qself, ref path) => {
+                if path.segments.len() == 2 {
+                    debug!("yukang item_segment: {:?}", path.segments);
+                    if let [seg1, seg2] = path.segments
+                        && let Some(mut diag) = self
+                        .tcx
+                        .sess
+                        .diagnostic()
+                        .steal_diagnostic(seg1.ident.span, StashKey::CallInstanceMethod) 
+                        && let Some(&help) = diag.children.get(0) {
+                        let local_def_span = help.span;
+                        if self.suggest_instance_call(seg1, seg2, &local_def_span) {
+                            diag.set_primary_message(format!(
+                                "need to fix call instance method: {:?}",
+                                seg2.ident
+                            ));
+                            diag.emit();
+                        } else {
+                            diag.cancel();
+                        }
+                    }
+                }
+
                 return (
                     path.res,
                     opt_qself.as_ref().map(|qself| self.to_ty(qself)),

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1994,6 +1994,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             hir::QPath::TypeRelative(_, segment) => {
+                debug!("yukang point_at_path_if_possible segment={:?}", segment);
                 if self.point_at_generic_if_possible(error, def_id, param, segment) {
                     return true;
                 }

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -29,11 +29,11 @@ use rustc_trait_selection::traits::{
     FulfillmentError, Obligation, ObligationCause, ObligationCauseCode, OnUnimplementedNote,
 };
 
-use std::cmp::Ordering;
-use std::iter;
-
 use super::probe::{AutorefOrPtrAdjustment, IsSuggestion, Mode, ProbeScope};
 use super::{CandidateSource, MethodError, NoMatchData};
+use rustc_hir::intravisit::Visitor;
+use std::cmp::Ordering;
+use std::iter;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn is_fn_ty(&self, ty: Ty<'tcx>, span: Span) -> bool {
@@ -1407,6 +1407,63 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         false
     }
 
+    pub(crate) fn suggest_instance_call(
+        &self,
+        seg1: &hir::PathSegment<'_>,
+        seg2: &hir::PathSegment<'_>,
+        local_span: Span,
+    ) -> bool {
+        let map = self.infcx.tcx.hir();
+        let body_id = map.body_owned_by(seg1.hir_id.owner.def_id);
+        let body = map.body(body_id);
+
+        struct LetVisitor<'a> {
+            local_span: Span,
+            result: Option<&'a Ty<'a>>,
+        }
+
+        impl<'v> Visitor<'v> for LetVisitor<'_> {
+            fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) {
+                if self.result.is_some() {
+                    return;
+                }
+                if let hir::StmtKind::Local(hir::Local {
+                        span, ty, init: None, ..
+                    }) = &ex.kind && span.contains(self.local_span) {
+                        self.result = ty;
+                }
+                hir::intravisit::walk_stmt(self, ex);
+            }
+        }
+
+        let mut visitor = LetVisitor { local_span, result: None };
+        visitor.visit_body(&body);
+
+        let parent = self.tcx.hir().get_parent_node(seg1.hir_id);
+        let parent_expr = self.tcx.hir().find(parent);
+        debug!("yukang parent_expr: {:?}", parent_expr);
+        let node = self.tcx.hir().get_parent_node(seg1.hir_id);
+        let ty = self.typeck_results.borrow().node_type_opt(node);
+
+        debug!("yukang suggest_instance_call ty: {:?}", ty);
+        if let Some(Node::Expr(call_expr)) = self.tcx.hir().find(parent) &&
+            let Some(self_ty) = ty {
+            debug!("yukang trying to prob method");
+            let probe = self.lookup_probe(
+                seg1.ident.span,
+                seg2.ident,
+                self_ty,
+                call_expr,
+                ProbeScope::TraitsInScope,
+            );
+
+            if let Ok(_pick) = probe {
+                return true;
+            }
+        }
+        return false;
+    }
+
     fn check_for_field_method(
         &self,
         err: &mut Diagnostic,

compiler/rustc_resolve/src/diagnostics.rs

@@ -2022,7 +2022,7 @@ impl<'a> Resolver<'a> {
             // 3. check whether the name refers to an item in local scope
             if suggestion.is_none() &&
                 let Some(ribs) = ribs &&
-                let Some(LexicalScopeBinding::Res(Res::Local(_))) = self.resolve_ident_in_lexical_scope(
+                let Some(LexicalScopeBinding::Res(Res::Local(local_id))) = self.resolve_ident_in_lexical_scope(
                     ident,
                     ValueNS,
                     parent_scope,
@@ -2033,21 +2033,34 @@ impl<'a> Resolver<'a> {
                 {
                     let sm = self.session.source_map();
                     let code_span = sm
-                        .span_extend_while(ident.span.shrink_to_hi(), |c| c != '\n')
+                        .span_extend_while(ident.span.shrink_to_hi(), |c| c == ':')
                         .unwrap_or(ident.span);
                     let code = sm.span_to_snippet(code_span).unwrap();
-                    if code.starts_with("::") && code.matches("::").count() == 1 {
-                        suggestion = Some((
+                    if code == "::" {
+                        let local_span = *self.pat_span_map.get(&local_id).unwrap();
+                        let mut err = struct_span_err!(
+                            self.session,
+                            ident.span,
+                            E0434,
+                            "{}",
+                            format!(
+                                "`{}` is not a crate or module, maybe you meant to call instance method",
+                                ident
+                            )
+                        );
+                        err.span_warn(local_span, "ident is defined at here");
+                        err.stash(ident.span, rustc_errors::StashKey::CallInstanceMethod);
+                       /*  suggestion = Some((
                             vec![(
-                                sm.span_extend_while(ident.span, |c| c == ':').unwrap(),
+                                sm.span_extend_while(id ent.span, |c| c == ':').unwrap(),
                                 format!("{}.", ident),
                             )],
                             format!(
                                 "`{}` is not a crate or module, maybe you meant to call instance method",
                                 ident
                             ),
                             Applicability::MaybeIncorrect,
-                        ))
+                        )) */
                     }
                 };
             (format!("use of undeclared crate or module `{}`", ident), suggestion)