clean up debug code

Author: chenyukang

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -1723,21 +1723,13 @@ impl<'a> Parser<'a> {
         lo: Span,
         result: PResult<'a, P<Expr>>,
     ) -> P<Expr> {
-        use crate::parser::DUMMY_NODE_ID;
         match result {
             Ok(x) => x,
             Err(mut err) => {
                 err.emit();
                 // Recover from parse error, callers expect the closing delim to be consumed.
                 self.consume_block(delim, ConsumeClosingDelim::Yes);
-                debug!("recover_seq_parse_error: consumed tokens until {:?} {:?}", lo, self.token);
-                let res = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err);
-                if res.id == DUMMY_NODE_ID {
-                    //panic!("debug now ....: {:?}", res);
-                    res
-                } else {
-                    res
-                }
+                self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err)
             }
         }
     }
@@ -1819,7 +1811,6 @@ impl<'a> Parser<'a> {
                         && brace_depth == 0
                         && bracket_depth == 0 =>
                 {
-                    debug!("recover_stmt_ return - Comma");
                     break;
                 }
                 _ => self.bump(),

compiler/rustc_parse/src/parser/path.rs

@@ -205,9 +205,6 @@ impl<'a> Parser<'a> {
             segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
         }
         self.parse_path_segments(&mut segments, style, ty_generics)?;
-        if segments.len() > 1 {
-            //panic!("debug now ...");
-        }
         Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
     }
 
@@ -727,7 +724,6 @@ impl<'a> Parser<'a> {
         &mut self,
         ty_generics: Option<&Generics>,
     ) -> PResult<'a, Option<GenericArg>> {
-        debug!("pain");
         let start = self.token.span;
         let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
             // Parse lifetime argument.
@@ -736,7 +732,6 @@ impl<'a> Parser<'a> {
             // Parse const argument.
             GenericArg::Const(self.parse_const_arg()?)
         } else if self.check_type() {
-            debug!("type");
             // Parse type argument.
 
             // Proactively create a parser snapshot enabling us to rewind and try to reparse the

compiler/rustc_resolve/src/diagnostics.rs

@@ -775,10 +775,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 .sess
                 .create_err(errs::SelfImportOnlyInImportListWithNonEmptyPrefix { span }),
             ResolutionError::FailedToResolve { label, suggestion } => {
-                if label.len() > 0 {
-                    //panic!("debug now");
-                }
-
                 let mut err =
                     struct_span_err!(self.tcx.sess, span, E0433, "failed to resolve: {}", &label);
                 err.span_label(span, label);

compiler/rustc_resolve/src/late.rs

@@ -3710,14 +3710,17 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
     }
 
     /// Handles paths that may refer to associated items.
-    #[instrument(level = "debug", skip(self))]
     fn resolve_qpath(
         &mut self,
         qself: &Option<P<QSelf>>,
         path: &[Segment],
         ns: Namespace,
         finalize: Finalize,
     ) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>> {
+        debug!(
+            "resolve_qpath(qself={:?}, path={:?}, ns={:?}, finalize={:?})",
+            qself, path, ns, finalize,
+        );
         if let Some(qself) = qself {
             if qself.position == 0 {
                 // This is a case like `<T>::B`, where there is no

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -305,7 +305,6 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
 
     /// Handles error reporting for `smart_resolve_path_fragment` function.
     /// Creates base error and amends it with one short label and possibly some longer helps/notes.
-    #[instrument(level = "debug", skip(self))]
     pub(crate) fn smart_resolve_report_errors(
         &mut self,
         path: &[Segment],