Rename {} -> {:?} in formatting macros

Author: Marwes

compiler.rs

@@ -454,7 +454,7 @@ impl <'a> Compiler<'a> {
     }
 
     fn compile_binding(&mut self, bind : &Binding<Id>) -> SuperCombinator {
-        debug!("Compiling binding {} :: {}", bind.name, bind.name.typ);
+        debug!("Compiling binding {:?} :: {:?}", bind.name, bind.name.typ);
         let dict_arg = if bind.name.typ.constraints.len() > 0 { 1 } else { 0 };
         self.context = bind.name.typ.constraints.clone();
         let mut instructions = Vec::new();
@@ -463,15 +463,15 @@ impl <'a> Compiler<'a> {
             if dict_arg == 1 {
                 this.new_stack_var(Name { name: intern("$dict"), uid: 0 });
             }
-            debug!("{} {}\n {}", bind.name, dict_arg, bind.expression);
+            debug!("{:?} {:?}\n {:?}", bind.name, dict_arg, bind.expression);
             arity = this.compile_lambda_binding(&bind.expression, &mut instructions) + dict_arg;
             instructions.push(Update(0));
             if arity != 0 {
                 instructions.push(Pop(arity));
             }
             instructions.push(Unwind);
         });
-        debug!("{} :: {} compiled as:\n{}", bind.name, bind.name.typ, instructions);
+        debug!("{:?} :: {:?} compiled as:\n{:?}", bind.name, bind.name.typ, instructions);
         SuperCombinator {
             assembly_id: self.assemblies.len(),
             typ: bind.name.typ.clone(),
@@ -720,7 +720,7 @@ impl <'a> Compiler<'a> {
                 //might be created which is returned here and added to the assembly
                 let mut is_primitive = false;
                 let var = self.find(name.name)
-                    .unwrap_or_else(|| panic!("Error: Undefined variable {}", *name));
+                    .unwrap_or_else(|| panic!("Error: Undefined variable {:?}", *name));
                 match var {
                     Var::Primitive(..) => is_primitive = true,
                     _ => ()
@@ -735,11 +735,11 @@ impl <'a> Compiler<'a> {
                     }
                     Var::Builtin(index) => { instructions.push(PushBuiltin(index)); }
                     Var::Class(typ, constraints, var) => {
-                        debug!("Var::Class ({}, {}, {}) {}", typ, constraints, var, expr.get_type());
+                        debug!("Var::Class ({:?}, {:?}, {:?}) {:?}", typ, constraints, var, expr.get_type());
                         self.compile_instance_variable(expr.get_type(), instructions, name.name, typ, constraints, var);
                     }
                     Var::Constraint(index, bind_type, constraints) => {
-                        debug!("Var::Constraint {} ({}, {}, {})", name, index, bind_type, constraints);
+                        debug!("Var::Constraint {:?} ({:?}, {:?}, {:?})", name, index, bind_type, constraints);
                         self.compile_with_constraints(name.name, expr.get_type(), bind_type, constraints, instructions);
                         instructions.push(PushGlobal(index));
                         instructions.push(Mkap);
@@ -749,7 +749,7 @@ impl <'a> Compiler<'a> {
                             instructions.push(instruction);
                         }
                         else {
-                            panic!("Expected {} arguments for {}, got {}", num_args, name, arg_length)
+                            panic!("Expected {:?} arguments for {:?}, got {:?}", num_args, name, arg_length)
                         }
                         is_function = false;
                     }
@@ -821,7 +821,7 @@ impl <'a> Compiler<'a> {
                         instructions.push(PushGlobal(index));
                         instructions.push(Mkap);
                     }
-                    _ => panic!("Unregistered instance function {}", instance_fn_name)
+                    _ => panic!("Unregistered instance function {:?}", instance_fn_name)
                 }
             }
             None => {
@@ -853,7 +853,7 @@ impl <'a> Compiler<'a> {
     }
 
     fn push_dictionary(&mut self, context: &[Constraint<Name>], constraints: &[(Name, Type)], instructions: &mut Vec<Instruction>) {
-        debug!("Push dictionary {} ==> {}", context, constraints);
+        debug!("Push dictionary {:?} ==> {:?}", context, constraints);
         for &(ref class, ref typ) in constraints.iter() {
             self.fold_dictionary(*class, typ, instructions);
             instructions.push(ConstructDictionary(constraints.len()));
@@ -864,13 +864,13 @@ impl <'a> Compiler<'a> {
     fn fold_dictionary(&mut self, class: Name, typ: &Type, instructions: &mut Vec<Instruction>) {
         match *typ {
             Type::Constructor(ref ctor) => {//Simple
-                debug!("Simple for {}", ctor);
+                debug!("Simple for {:?}", ctor);
                 //Push static dictionary to the top of the stack
                 let index = self.find_dictionary_index(&[(class.clone(), typ.clone())]);
                 instructions.push(PushDictionary(index));
             }
             Type::Application(ref lhs, ref rhs) => {
-                debug!("App for ({} {})", lhs, rhs);
+                debug!("App for ({:?} {:?})", lhs, rhs);
                 //For function in functions
                 // Mkap function fold_dictionary(rhs)
                 self.fold_dictionary(class, *lhs, instructions);
@@ -894,11 +894,11 @@ impl <'a> Compiler<'a> {
                     let num_class_functions = self.find_class(class)
                         .map(|(_, _, decls)| decls.len())
                         .unwrap();
-                    debug!("Use previous dict for {} at {}..{}", var, index, num_class_functions);
+                    debug!("Use previous dict for {:?} at {:?}..{:?}", var, index, num_class_functions);
                     instructions.push(PushDictionaryRange(index, num_class_functions));
                 }
                 else {
-                    debug!("No dict for {}", var);
+                    debug!("No dict for {:?}", var);
                 }
             }
             _ => panic!("Did not expect generic")
@@ -908,7 +908,7 @@ impl <'a> Compiler<'a> {
     ///Lookup which index in the instance dictionary that holds the function called 'name'
     fn push_dictionary_member(&self, constraints: &[Constraint<Name>], name: Name) -> Option<uint> {
         if constraints.len() == 0 {
-            panic!("Attempted to push dictionary member '{}' with no constraints", name)
+            panic!("Attempted to push dictionary member '{:?}' with no constraints", name)
         }
         let mut ii = 0;
         for c in constraints.iter() {
@@ -974,7 +974,7 @@ impl <'a> Compiler<'a> {
                 for decl in declarations.iter() {
                     let x = match extract_applied_type(typ) {
                         &Type::Constructor(ref x) => x,
-                        _ => panic!("{}", typ)
+                        _ => panic!("{:?}", typ)
                     };
                     let mut b = "#".to_string();
                     b.push_str(x.name.as_slice());
@@ -988,7 +988,7 @@ impl <'a> Compiler<'a> {
                         Some(Var::Constraint(index, _, _)) => {
                             function_indexes.push(index as uint);//TODO this is not really correct since this function requires a dictionary
                         }
-                        var => panic!("Did not find function {} {}", name, var)
+                        var => panic!("Did not find function {:?} {:?}", name, var)
                     }
                 }
                 None
@@ -1000,7 +1000,7 @@ impl <'a> Compiler<'a> {
     ///An index to the Jump instruction which is taken when the match fails is stored in the branches vector
     ///These instructions will need to be updated later with the correct jump location.
     fn compile_pattern(&mut self, pattern: &Pattern<Id>, branches: &mut Vec<uint>, instructions: &mut Vec<Instruction>, stack_size: uint) -> uint {
-        debug!("Pattern {} at {}", pattern, stack_size);
+        debug!("Pattern {:?} at {:?}", pattern, stack_size);
         match pattern {
             &Pattern::Constructor(ref name, ref patterns) => {
                 instructions.push(Push(stack_size));
@@ -1010,7 +1010,7 @@ impl <'a> Compiler<'a> {
                         branches.push(instructions.len());
                         instructions.push(Jump(0));
                     }
-                    _ => panic!("Undefined constructor {}", *name)
+                    _ => panic!("Undefined constructor {:?}", *name)
                 }
                 instructions.push(Split(patterns.len()));
                 self.stackSize += patterns.len();

core.rs

@@ -87,13 +87,13 @@ pub enum Expr<Ident> {
 
 impl fmt::Show for LiteralData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.value)
+        write!(f, "{:?}", self.value)
     }
 }
 
 impl <T: fmt::Show> fmt::Show for Binding<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} = {}", self.name, self.expression)
+        write!(f, "{:?} = {:?}", self.name, self.expression)
     }
 }
 
@@ -105,18 +105,18 @@ impl <T: fmt::Show> fmt::Show for Expr<T> {
 }
 impl <T: fmt::Show> fmt::Show for Alternative<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} -> {}", self.pattern, self.expression)
+        write!(f, "{:?} -> {:?}", self.pattern, self.expression)
     }
 }
 impl <T: fmt::Show> fmt::Show for Pattern<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Pattern::Identifier(ref s) => write!(f, "{}", s),
-            Pattern::Number(ref i) => write!(f, "{}", i),
+            Pattern::Identifier(ref s) => write!(f, "{:?}", s),
+            Pattern::Number(ref i) => write!(f, "{:?}", i),
             Pattern::Constructor(ref name, ref patterns) => {
-                try!(write!(f, "({} ", name));
+                try!(write!(f, "({:?} ", name));
                 for p in patterns.iter() {
-                    try!(write!(f, " {}", p));
+                    try!(write!(f, " {:?}", p));
                 }
                 write!(f, ")")
             }
@@ -138,7 +138,7 @@ impl <Ident: Typed> Typed for Expr<Ident> {
             &Expr::Apply(ref func, _) => {
                 match func.get_type() {
                     &Type::Application(_, ref a) => { let a2: &Type = *a; a2 }
-                    x => panic!("The function in Apply must be a type application, found {}", x)
+                    x => panic!("The function in Apply must be a type application, found {:?}", x)
                 }
             }
             &Expr::Lambda(ref arg, _) => arg.get_type(),
@@ -173,7 +173,7 @@ pub struct Id<T = Name> {
 
 impl fmt::Show for Id {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.name)
+        write!(f, "{:?}", self.name)
     }
 }
 
@@ -503,7 +503,7 @@ pub mod translate {
         class_decls.iter()
             .filter(|decl| instance.bindings.iter().find(|bind| bind.name.as_slice().ends_with(decl.name.as_slice())).is_none())
             .map(|decl| {
-                debug!("Create default function for {} ({}) {}", instance.classname, instance.typ, decl.name);
+                debug!("Create default function for {:?} ({:?}) {:?}", instance.classname, instance.typ, decl.name);
                 //The stub functions will naturally have the same type as the function in the class but with the variable replaced
                 //with the instance's type
                 let mut typ = decl.typ.clone();
@@ -629,7 +629,7 @@ impl <'a> Translator<'a> {
     ///Translates
     ///do { expr; stmts } = expr >> do { stmts; }
     fn do_bind2_id(&mut self, m_a: Type, m_b: Type) -> Expr<Id<Name>> {
-        debug!("m_a {}", m_a);
+        debug!("m_a {:?}", m_a);
         let c = match *m_a.appl() {
             Type::Variable(ref var) => vec![Constraint { class: Name { name: intern("Monad"), uid: 0 }, variables: vec![var.clone()] }],
             _ => vec![]
@@ -647,7 +647,7 @@ impl <'a> Translator<'a> {
         let m_a = expr.get_type().clone();
         let a = m_a.appr().clone();
         let m_b = result.get_type().clone();
-                debug!("m_a {}", m_a);
+                debug!("m_a {:?}", m_a);
         let c = match *m_a.appl() {
             Type::Variable(ref var) => vec![Constraint { class: Name { name: intern("Monad"), uid: 0 }, variables: vec![var.clone()] }],
             _ => vec![]
@@ -822,7 +822,7 @@ impl <'a> Translator<'a> {
         }).collect();
         let mut expr = self.translate_equations_(equations);
         expr = make_lambda(arg_ids.into_iter(), expr);
-        debug!("Desugared {} :: {}\n {}", name.name, name.typ, expr);
+        debug!("Desugared {:?} :: {:?}\n {:?}", name.name, name.typ, expr);
         Binding {
             name: name,
             expression: expr
@@ -834,7 +834,7 @@ impl <'a> Translator<'a> {
             eqs.push(Equation(ps.as_slice(), (bs.as_slice(), e)));
         }
         for e in eqs.iter() {
-            debug!("{}", e);
+            debug!("{:?}", e);
         }
         self.translate_equations(eqs.as_slice())
     }
@@ -864,7 +864,7 @@ impl <'a> Translator<'a> {
                 _ => true
             }
         }
-        debug!("In {}", equations);
+        debug!("In {:?}", equations);
         let &Equation(ps, (where_bindings_bindings, e)) = &equations[0];
         if ps.len() == 0 {
             assert_eq!(equations.len(), 1);//Otherwise multiple matches for this group

deriving.rs

@@ -22,7 +22,7 @@ pub fn generate_deriving(instances: &mut Vec<Instance<Id<Name>>>, data: &DataDef
             "Ord" => {
                 let mut bindings = Vec::new();
                 let b = gen.generate_ord(data);
-                debug!("Generated Ord {} ->>\n{}", data.typ, b);
+                debug!("Generated Ord {:?} ->>\n{:?}", data.typ, b);
                 bindings.push(b);
                 instances.push(Instance {
                     constraints: box [],
@@ -31,7 +31,7 @@ pub fn generate_deriving(instances: &mut Vec<Instance<Id<Name>>>, data: &DataDef
                     bindings: bindings
                 });
             }
-            x => panic!("Cannot generate instance for class {}", x)
+            x => panic!("Cannot generate instance for class {:?}", x)
         }
     }
 }

infix.rs

@@ -76,7 +76,7 @@ impl PrecedenceVisitor {
                                             reduce(&mut expr_stack, &mut op_stack);
                                         }
                                         (Assoc::Right, Assoc::Right) => {
-                                            debug!("Shift op {}", op);
+                                            debug!("Shift op {:?}", op);
                                             op_stack.push(op);
                                             break
                                         }

interner.rs

@@ -34,7 +34,7 @@ impl Interner {
             self.strings.get(i).as_slice()
         }
         else {
-            panic!("Invalid InternedStr {}", i)
+            panic!("Invalid InternedStr {:?}", i)
         }
     }
 }
@@ -67,6 +67,6 @@ impl fmt::Show for InternedStr {
 }
 impl fmt::String for InternedStr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.as_slice())
+        write!(f, "{:?}", self.as_slice())
     }
 }

lambda_lift.rs

@@ -275,7 +275,7 @@ test2 x =
                         assert!(check_args(&binds[0].expression, args.as_slice()));
                         assert_eq!(Identifier(binds[0].name.clone()), **body);
                     }
-                    _ => assert!(false, "Expected Let, found {}", bind.expression)
+                    _ => assert!(false, "Expected Let, found {:?}", bind.expression)
                 }
                 self.count += 1;
             }

lexer.rs

@@ -80,13 +80,13 @@ impl <T: PartialEq> PartialEq for Located<T> {
 
 impl <T: fmt::Show> fmt::Show for Located<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.node)
+        write!(f, "{:?}", self.node)
     }
 }
 
 impl fmt::Show for Location {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.row, self.column)
+        write!(f, "{:?}:{:?}", self.row, self.column)
     }
 }
 
@@ -341,7 +341,7 @@ impl <Stream : Iterator<Item=char>> Lexer<Stream> {
                 //L (t:ts) (m:ms) 	= 	} : (L (t:ts) ms) 	if m /= 0 and parse-error(t)
                 let m = *self.indentLevels.get(self.indentLevels.len() - 1);
                 if m != 0 {//If not a explicit '}'
-                    debug!("ParseError on token {}, inserting }}", self.current().token);
+                    debug!("ParseError on token {:?}, inserting }}", self.current().token);
                     self.indentLevels.pop();
                     let loc = self.current().location;
                     self.tokens.push_back(Token::new(&self.interner, RBRACE, "}", loc));
@@ -532,13 +532,13 @@ impl <Stream : Iterator<Item=char>> Lexer<Stream> {
         else if c == '`' {
             let x = self.read_char().expect("Unexpected end of input");
             if !x.is_alphabetic() && x != '_' {
-                panic!("Parse error on '{}'", x);
+                panic!("Parse error on '{:?}'", x);
             }
             let mut token = self.scan_identifier(x, startLocation);
             let end_tick = self.read_char();
             match end_tick {
                 Some('`') => (),
-                Some(x) => panic!("Parse error on '{}'", x),
+                Some(x) => panic!("Parse error on '{:?}'", x),
                 None => panic!("Unexpected end of input")
             }
             token.token = OPERATOR;