librustc: Remove all uses of {:?}.

Author: luqmana

src/librustc/driver/pretty.rs

@@ -518,7 +518,7 @@ pub fn pretty_print_input(sess: Session,
                 }
                 None => {
                     let message = format!("--pretty=flowgraph needs \
-                                           block, fn, or method; got {:?}",
+                                           block, fn, or method; got {}",
                                           node);
 
                     // point to what was found, if there's an
@@ -542,7 +542,6 @@ fn print_flowgraph<W:io::Writer>(variants: Vec<borrowck_dot::Variant>,
         blocks::BlockCode(block) => cfg::CFG::new(ty_cx, &*block),
         blocks::FnLikeCode(fn_like) => cfg::CFG::new(ty_cx, &*fn_like.body()),
     };
-    debug!("cfg: {:?}", cfg);
 
     match code {
         _ if variants.len() == 0 => {

src/librustc/metadata/csearch.rs

@@ -226,13 +226,13 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
     let class_doc = expect(tcx.sess.diagnostic(),
                            decoder::maybe_find_item(class_id.node, all_items),
                            || {
-        (format!("get_field_type: class ID {:?} not found",
+        (format!("get_field_type: class ID {} not found",
                  class_id)).to_string()
     });
     let the_field = expect(tcx.sess.diagnostic(),
         decoder::maybe_find_item(def.node, class_doc),
         || {
-            (format!("get_field_type: in class {:?}, field ID {:?} not found",
+            (format!("get_field_type: in class {}, field ID {} not found",
                     class_id,
                     def)).to_string()
         });

src/librustc/metadata/encoder.rs

@@ -256,7 +256,7 @@ fn encode_symbol(ecx: &EncodeContext,
     rbml_w.start_tag(tag_items_data_item_symbol);
     match ecx.item_symbols.borrow().find(&id) {
         Some(x) => {
-            debug!("encode_symbol(id={:?}, str={})", id, *x);
+            debug!("encode_symbol(id={}, str={})", id, *x);
             rbml_w.writer.write(x.as_bytes());
         }
         None => {
@@ -308,7 +308,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
                             id: NodeId,
                             variants: &[P<Variant>],
                             index: &mut Vec<entry<i64>>) {
-    debug!("encode_enum_variant_info(id={:?})", id);
+    debug!("encode_enum_variant_info(id={})", id);
 
     let mut disr_val = 0;
     let mut i = 0;
@@ -592,7 +592,7 @@ fn encode_info_for_mod(ecx: &EncodeContext,
             ItemImpl(..) => {
                 let (ident, did) = (item.ident, item.id);
                 debug!("(encoding info for module) ... encoding impl {} \
-                        ({:?}/{:?})",
+                        ({}/{})",
                         token::get_ident(ident),
                         did, ecx.tcx.map.node_to_string(did));
 
@@ -853,7 +853,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
                           parent_id: NodeId,
                           ast_item_opt: Option<&ImplItem>) {
 
-    debug!("encode_info_for_method: {:?} {}", m.def_id,
+    debug!("encode_info_for_method: {} {}", m.def_id,
            token::get_ident(m.ident));
     rbml_w.start_tag(tag_items_data_item);
 

src/librustc/metadata/filesearch.rs

@@ -39,7 +39,7 @@ impl<'a> FileSearch<'a> {
         let mut visited_dirs = HashSet::new();
         let mut found = false;
 
-        debug!("filesearch: searching additional lib search paths [{:?}]",
+        debug!("filesearch: searching additional lib search paths [{}]",
                self.addl_lib_search_paths.borrow().len());
         for path in self.addl_lib_search_paths.borrow().iter() {
             match f(path) {
@@ -66,7 +66,7 @@ impl<'a> FileSearch<'a> {
             for path in rustpath.iter() {
                 let tlib_path = make_rustpkg_lib_path(
                     self.sysroot, path, self.triple);
-                debug!("is {} in visited_dirs? {:?}", tlib_path.display(),
+                debug!("is {} in visited_dirs? {}", tlib_path.display(),
                         visited_dirs.contains_equiv(&tlib_path.as_vec().to_vec()));
 
                 if !visited_dirs.contains_equiv(&tlib_path.as_vec()) {

src/librustc/metadata/tydecode.rs

@@ -43,6 +43,7 @@ use syntax::parse::token;
 // def-id will depend on where it originated from.  Therefore, the conversion
 // function is given an indicator of the source of the def-id.  See
 // astencode.rs for more information.
+#[deriving(Show)]
 pub enum DefIdSource {
     // Identifies a struct, trait, enum, etc.
     NominalType,
@@ -390,7 +391,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
       }
       'p' => {
         let did = parse_def(st, TypeParameter, |x,y| conv(x,y));
-        debug!("parsed ty_param: did={:?}", did);
+        debug!("parsed ty_param: did={}", did);
         let index = parse_uint(st);
         assert_eq!(next(st), '|');
         let space = parse_param_space(st);
@@ -603,12 +604,12 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
 
     let crate_num = match uint::parse_bytes(crate_part, 10u) {
        Some(cn) => cn as ast::CrateNum,
-       None => fail!("internal error: parse_def_id: crate number expected, found {:?}",
+       None => fail!("internal error: parse_def_id: crate number expected, found {}",
                      crate_part)
     };
     let def_num = match uint::parse_bytes(def_part, 10u) {
        Some(dn) => dn as ast::NodeId,
-       None => fail!("internal error: parse_def_id: id expected, found {:?}",
+       None => fail!("internal error: parse_def_id: id expected, found {}",
                      def_part)
     };
     ast::DefId { krate: crate_num, node: def_num }

src/librustc/middle/astencode.rs

@@ -1807,7 +1807,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
             NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did),
             TypeParameter => dcx.tr_intern_def_id(did)
         };
-        debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r);
+        debug!("convert_def_id(source={}, did={})={}", source, did, r);
         return r;
     }
 }
@@ -1841,7 +1841,7 @@ fn decode_side_tables(dcx: &DecodeContext,
                     }
                     c::tag_table_node_type => {
                         let ty = val_dsr.read_ty(dcx);
-                        debug!("inserting ty for node {:?}: {}",
+                        debug!("inserting ty for node {}: {}",
                                id, ty_to_string(dcx.tcx, ty));
                         dcx.tcx.node_types.borrow_mut().insert(id as uint, ty);
                     }

src/librustc/middle/borrowck/check_loans.rs

@@ -119,7 +119,7 @@ impl<'a, 'tcx> euv::Delegate for CheckLoanCtxt<'a, 'tcx> {
               loan_cause: euv::LoanCause)
     {
         debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \
-               bk={}, loan_cause={:?})",
+               bk={}, loan_cause={})",
                borrow_id, cmt.repr(self.tcx()), loan_region,
                bk, loan_cause);
 
@@ -185,7 +185,7 @@ pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
                                      all_loans: &[Loan],
                                      decl: &ast::FnDecl,
                                      body: &ast::Block) {
-    debug!("check_loans(body id={:?})", body.id);
+    debug!("check_loans(body id={})", body.id);
 
     let mut clcx = CheckLoanCtxt {
         bccx: bccx,
@@ -336,10 +336,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
         //! issued when we enter `scope_id` (for example, we do not
         //! permit two `&mut` borrows of the same variable).
 
-        debug!("check_for_conflicting_loans(scope_id={:?})", scope_id);
+        debug!("check_for_conflicting_loans(scope_id={})", scope_id);
 
         let new_loan_indices = self.loans_generated_by(scope_id);
-        debug!("new_loan_indices = {:?}", new_loan_indices);
+        debug!("new_loan_indices = {}", new_loan_indices);
 
         self.each_issued_loan(scope_id, |issued_loan| {
             for &new_loan_index in new_loan_indices.iter() {
@@ -651,7 +651,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                                        use_path: &LoanPath,
                                        borrow_kind: ty::BorrowKind)
                                        -> UseError {
-        debug!("analyze_restrictions_on_use(expr_id={:?}, use_path={})",
+        debug!("analyze_restrictions_on_use(expr_id={}, use_path={})",
                self.tcx().map.node_to_string(expr_id),
                use_path.repr(self.tcx()));
 
@@ -679,7 +679,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
          * is using a moved/uninitialized value
          */
 
-        debug!("check_if_path_is_moved(id={:?}, use_kind={:?}, lp={})",
+        debug!("check_if_path_is_moved(id={}, use_kind={}, lp={})",
                id, use_kind, lp.repr(self.bccx.tcx));
         let base_lp = owned_ptr_base_path_rc(lp);
         self.move_data.each_move_of(id, &base_lp, |the_move, moved_lp| {

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -112,7 +112,7 @@ impl<'a, 'tcx> euv::Delegate for GatherLoanCtxt<'a, 'tcx> {
               loan_cause: euv::LoanCause)
     {
         debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \
-               bk={}, loan_cause={:?})",
+               bk={}, loan_cause={})",
                borrow_id, cmt.repr(self.tcx()), loan_region,
                bk, loan_cause);
 
@@ -218,8 +218,8 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
          * dynamically that they are not freed.
          */
 
-        debug!("guarantee_valid(borrow_id={:?}, cmt={}, \
-                req_mutbl={:?}, loan_region={:?})",
+        debug!("guarantee_valid(borrow_id={}, cmt={}, \
+                req_mutbl={}, loan_region={})",
                borrow_id,
                cmt.repr(self.tcx()),
                req_kind,
@@ -257,7 +257,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
             self.bccx, borrow_span, cause,
             cmt.clone(), loan_region);
 
-        debug!("guarantee_valid(): restrictions={:?}", restr);
+        debug!("guarantee_valid(): restrictions={}", restr);
 
         // Create the loan record (if needed).
         let loan = match restr {
@@ -289,17 +289,17 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
                     ty::ReInfer(..) => {
                         self.tcx().sess.span_bug(
                             cmt.span,
-                            format!("invalid borrow lifetime: {:?}",
+                            format!("invalid borrow lifetime: {}",
                                     loan_region).as_slice());
                     }
                 };
-                debug!("loan_scope = {:?}", loan_scope);
+                debug!("loan_scope = {}", loan_scope);
 
                 let gen_scope = self.compute_gen_scope(borrow_id, loan_scope);
-                debug!("gen_scope = {:?}", gen_scope);
+                debug!("gen_scope = {}", gen_scope);
 
                 let kill_scope = self.compute_kill_scope(loan_scope, &*loan_path);
-                debug!("kill_scope = {:?}", kill_scope);
+                debug!("kill_scope = {}", kill_scope);
 
                 if req_kind == ty::MutBorrow {
                     self.mark_loan_path_as_mutated(&*loan_path);
@@ -318,7 +318,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
             }
         };
 
-        debug!("guarantee_valid(borrow_id={:?}), loan={}",
+        debug!("guarantee_valid(borrow_id={}), loan={}",
                borrow_id, loan.repr(self.tcx()));
 
         // let loan_path = loan.loan_path;

src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -21,6 +21,7 @@ use util::ppaux::Repr;
 
 use std::rc::Rc;
 
+#[deriving(Show)]
 pub enum RestrictionResult {
     Safe,
     SafeIf(Rc<LoanPath>, Vec<Rc<LoanPath>>)

src/librustc/middle/borrowck/mod.rs

@@ -264,14 +264,14 @@ impl Loan {
     }
 }
 
-#[deriving(PartialEq, Eq, Hash)]
+#[deriving(PartialEq, Eq, Hash, Show)]
 pub enum LoanPath {
     LpVar(ast::NodeId),               // `x` in doc.rs
     LpUpvar(ty::UpvarId),             // `x` captured by-value into closure
     LpExtend(Rc<LoanPath>, mc::MutabilityCategory, LoanPathElem)
 }
 
-#[deriving(PartialEq, Eq, Hash)]
+#[deriving(PartialEq, Eq, Hash, Show)]
 pub enum LoanPathElem {
     LpDeref(mc::PointerKind),    // `*LV` in doc.rs
     LpInterior(mc::InteriorKind) // `LV.f` in doc.rs
@@ -421,6 +421,7 @@ pub enum AliasableViolationKind {
     BorrowViolation(euv::LoanCause)
 }
 
+#[deriving(Show)]
 pub enum MovedValueUseKind {
     MovedInUse,
     MovedInCapture,
@@ -530,8 +531,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span)
                     }
                     r => {
-                        self.tcx.sess.bug(format!("MoveExpr({:?}) maps to \
-                                                   {:?}, not Expr",
+                        self.tcx.sess.bug(format!("MoveExpr({}) maps to \
+                                                   {}, not Expr",
                                                   the_move.id,
                                                   r).as_slice())
                     }
@@ -566,8 +567,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span)
                     }
                     r => {
-                        self.tcx.sess.bug(format!("Captured({:?}) maps to \
-                                                   {:?}, not Expr",
+                        self.tcx.sess.bug(format!("Captured({}) maps to \
+                                                   {}, not Expr",
                                                   the_move.id,
                                                   r).as_slice())
                     }
@@ -892,7 +893,7 @@ impl DataFlowOperator for LoanDataFlowOperator {
 
 impl Repr for Loan {
     fn repr(&self, tcx: &ty::ctxt) -> String {
-        format!("Loan_{:?}({}, {:?}, {:?}-{:?}, {})",
+        format!("Loan_{}({}, {}, {}-{}, {})",
                  self.index,
                  self.loan_path.repr(tcx),
                  self.kind,

src/librustc/middle/borrowck/move_data.rs

@@ -68,7 +68,7 @@ pub struct FlowedMoveData<'a, 'tcx: 'a> {
 }
 
 /// Index into `MoveData.paths`, used like a pointer
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct MovePathIndex(uint);
 
 impl MovePathIndex {
@@ -120,7 +120,7 @@ pub struct MovePath {
     pub next_sibling: MovePathIndex,
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub enum MoveKind {
     Declared,   // When declared, variables start out "moved".
     MoveExpr,   // Expression or binding that moves a variable
@@ -284,7 +284,7 @@ impl MoveData {
             }
         };
 
-        debug!("move_path(lp={}, index={:?})",
+        debug!("move_path(lp={}, index={})",
                lp.repr(tcx),
                index);
 
@@ -341,7 +341,7 @@ impl MoveData {
          * location `id` with kind `kind`.
          */
 
-        debug!("add_move(lp={}, id={:?}, kind={:?})",
+        debug!("add_move(lp={}, id={}, kind={})",
                lp.repr(tcx),
                id,
                kind);
@@ -372,7 +372,7 @@ impl MoveData {
          * location `id` with the given `span`.
          */
 
-        debug!("add_assignment(lp={}, assign_id={:?}, assignee_id={:?}",
+        debug!("add_assignment(lp={}, assign_id={}, assignee_id={}",
                lp.repr(tcx), assign_id, assignee_id);
 
         let path_index = self.move_path(tcx, lp.clone());
@@ -391,12 +391,12 @@ impl MoveData {
         };
 
         if self.is_var_path(path_index) {
-            debug!("add_assignment[var](lp={}, assignment={}, path_index={:?})",
+            debug!("add_assignment[var](lp={}, assignment={}, path_index={})",
                    lp.repr(tcx), self.var_assignments.borrow().len(), path_index);
 
             self.var_assignments.borrow_mut().push(assignment);
         } else {
-            debug!("add_assignment[path](lp={}, path_index={:?})",
+            debug!("add_assignment[path](lp={}, path_index={})",
                    lp.repr(tcx), path_index);
 
             self.path_assignments.borrow_mut().push(assignment);