Fixed error starting with uppercase

Error messages cleaned in librustc/middle

Error messages cleaned in libsyntax

Error messages cleaned in libsyntax more agressively

Error messages cleaned in librustc more aggressively

Fixed affected tests

Fixed other failing tests

Last failing tests fixed

74 files changed, 167 insertions, 167 deletions

diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index 62fdff49168..531b8bf9034 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -76,7 +76,7 @@ pub fn WriteOutputFile(
             let result = llvm::LLVMRustWriteOutputFile(
                     Target, PM, M, Output, FileType);
             if !result {
-                llvm_err(sess, ~"Could not write output");
+                llvm_err(sess, ~"could not write output");
             }
         })
     }
@@ -189,7 +189,7 @@ pub mod write {
             for pass in sess.opts.custom_passes.iter() {
                 pass.with_c_str(|s| {
                     if !llvm::LLVMRustAddPass(mpm, s) {
-                        sess.warn(format!("Unknown pass {}, ignoring", *pass));
+                        sess.warn(format!("unknown pass {}, ignoring", *pass));
                     }
                 })
             }
@@ -876,11 +876,11 @@ fn link_binary_output(sess: Session,
     let obj_is_writeable = is_writeable(&obj_filename);
     let out_is_writeable = is_writeable(&out_filename);
     if !out_is_writeable {
-        sess.fatal(format!("Output file {} is not writeable -- check its permissions.",
+        sess.fatal(format!("output file {} is not writeable -- check its permissions.",
                            out_filename.display()));
     }
     else if !obj_is_writeable {
-        sess.fatal(format!("Object file {} is not writeable -- check its permissions.",
+        sess.fatal(format!("object file {} is not writeable -- check its permissions.",
                            obj_filename.display()));
     }
 
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
index 6fb7e749475..dc8598c10d0 100644
--- a/src/librustc/driver/session.rs
+++ b/src/librustc/driver/session.rs
@@ -308,7 +308,7 @@ impl Session_ {
     // This exists to help with refactoring to eliminate impossible
     // cases later on
     pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
-        self.span_bug(sp, format!("Impossible case reached: {}", msg));
+        self.span_bug(sp, format!("impossible case reached: {}", msg));
     }
     pub fn verbose(&self) -> bool { self.debugging_opt(VERBOSE) }
     pub fn time_passes(&self) -> bool { self.debugging_opt(TIME_PASSES) }
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index 8da097a1b6a..42e4d986837 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -527,7 +527,7 @@ fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
     let variadic = match next(st) {
         'V' => true,
         'N' => false,
-        r => fail!(format!("Bad variadic: {}", r)),
+        r => fail!(format!("bad variadic: {}", r)),
     };
     let ret_ty = parse_ty(st, |x,y| conv(x,y));
     ty::FnSig {binder_id: id,
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
index 4f6ac8607ee..08632b5c9a6 100644
--- a/src/librustc/metadata/tyencode.rs
+++ b/src/librustc/metadata/tyencode.rs
@@ -195,7 +195,7 @@ fn enc_region(w: &mut MemWriter, cx: @ctxt, r: ty::Region) {
         }
         ty::ReInfer(_) => {
             // these should not crop up after typeck
-            cx.diag.handler().bug("Cannot encode region variables");
+            cx.diag.handler().bug("cannot encode region variables");
         }
     }
 }
@@ -320,7 +320,7 @@ fn enc_sty(w: &mut MemWriter, cx: @ctxt, st: &ty::sty) {
             enc_bare_fn_ty(w, cx, f);
         }
         ty::ty_infer(_) => {
-            cx.diag.handler().bug("Cannot encode inference variable types");
+            cx.diag.handler().bug("cannot encode inference variable types");
         }
         ty::ty_param(param_ty {idx: id, def_id: did}) => {
             mywrite!(w, "p{}|{}", (cx.ds)(did), id);
@@ -334,7 +334,7 @@ fn enc_sty(w: &mut MemWriter, cx: @ctxt, st: &ty::sty) {
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_err => fail!("Shouldn't encode error type")
+        ty::ty_err => fail!("shouldn't encode error type")
     }
 }
 
diff --git a/src/librustc/middle/borrowck/gather_loans/lifetime.rs b/src/librustc/middle/borrowck/gather_loans/lifetime.rs
index 4c2f0986d9c..e151f398458 100644
--- a/src/librustc/middle/borrowck/gather_loans/lifetime.rs
+++ b/src/librustc/middle/borrowck/gather_loans/lifetime.rs
@@ -215,7 +215,7 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                 // the check above should fail for anything is not ReScope
                 self.bccx.tcx.sess.span_bug(
                     cmt_base.span,
-                    format!("Cannot issue root for scope region: {:?}",
+                    format!("cannot issue root for scope region: {:?}",
                          self.loan_region));
             }
         };
diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs
index 38d54ddfb42..173120e32f5 100644
--- a/src/librustc/middle/borrowck/gather_loans/mod.rs
+++ b/src/librustc/middle/borrowck/gather_loans/mod.rs
@@ -496,7 +496,7 @@ impl<'a> GatherLoanCtxt<'a> {
                     ty::ReInfer(..) => {
                         self.tcx().sess.span_bug(
                             cmt.span,
-                            format!("Invalid borrow lifetime: {:?}", loan_region));
+                            format!("invalid borrow lifetime: {:?}", loan_region));
                     }
                 };
                 debug!("loan_scope = {:?}", loan_scope);
@@ -820,7 +820,7 @@ impl<'a> GatherLoanCtxt<'a> {
             _ => {
                 self.tcx().sess.span_bug(
                     pat.span,
-                    format!("Type of slice pattern is not a slice"));
+                    format!("type of slice pattern is not a slice"));
             }
         }
     }
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 8f6d4de476b..6f3578f667d 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -769,14 +769,14 @@ impl BorrowckCtxt {
                             }
                             _ => {
                                 self.tcx.sess.bug(
-                                    format!("Loan path LpVar({:?}) maps to {:?}, not local",
+                                    format!("loan path LpVar({:?}) maps to {:?}, not local",
                                         id, pat));
                             }
                         }
                     }
                     r => {
                         self.tcx.sess.bug(
-                            format!("Loan path LpVar({:?}) maps to {:?}, not local",
+                            format!("loan path LpVar({:?}) maps to {:?}, not local",
                                  id, r));
                     }
                 }
diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs
index ca9bce19ab8..75549c5944d 100644
--- a/src/librustc/middle/borrowck/move_data.rs
+++ b/src/librustc/middle/borrowck/move_data.rs
@@ -494,7 +494,7 @@ impl MoveData {
                         dfcx_assign.add_kill(kill_id, assignment_index);
                     }
                     LpExtend(..) => {
-                        tcx.sess.bug("Var assignment for non var path");
+                        tcx.sess.bug("var assignment for non var path");
                     }
                 }
             }
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index eb9c434ca28..9c213558d9c 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -507,13 +507,13 @@ impl CFGBuilder {
                         }
                         self.tcx.sess.span_bug(
                             expr.span,
-                            format!("No loop scope for id {:?}", loop_id));
+                            format!("no loop scope for id {:?}", loop_id));
                     }
 
                     r => {
                         self.tcx.sess.span_bug(
                             expr.span,
-                            format!("Bad entry `{:?}` in def_map for label", r));
+                            format!("bad entry `{:?}` in def_map for label", r));
                     }
                 }
             }
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index d402305401e..ab9eff3a372 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -971,7 +971,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
                     _ => {
                         cx.tcx.sess.span_bug(
                             p.span,
-                            format!("Binding pattern {} is \
+                            format!("binding pattern {} is \
                                   not an identifier: {:?}",
                                  p.id, p.node));
                     }
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index cbe1e8f72d9..75874339f3a 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -342,8 +342,8 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
           Ok(const_float(f)) => Ok(const_float(-f)),
           Ok(const_int(i)) => Ok(const_int(-i)),
           Ok(const_uint(i)) => Ok(const_uint(-i)),
-          Ok(const_str(_)) => Err(~"Negate on string"),
-          Ok(const_bool(_)) => Err(~"Negate on boolean"),
+          Ok(const_str(_)) => Err(~"negate on string"),
+          Ok(const_bool(_)) => Err(~"negate on boolean"),
           ref err => ((*err).clone())
         }
       }
@@ -352,7 +352,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
           Ok(const_int(i)) => Ok(const_int(!i)),
           Ok(const_uint(i)) => Ok(const_uint(!i)),
           Ok(const_bool(b)) => Ok(const_bool(!b)),
-          _ => Err(~"Not on float or string")
+          _ => Err(~"not on float or string")
         }
       }
       ExprBinary(_, op, a, b) => {
@@ -371,7 +371,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
               BiNe => fromb(a != b),
               BiGe => fromb(a >= b),
               BiGt => fromb(a > b),
-              _ => Err(~"Can't do this op on floats")
+              _ => Err(~"can't do this op on floats")
             }
           }
           (Ok(const_int(a)), Ok(const_int(b))) => {
@@ -423,14 +423,14 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
             match op {
               BiShl => Ok(const_int(a << b)),
               BiShr => Ok(const_int(a >> b)),
-              _ => Err(~"Can't do this op on an int and uint")
+              _ => Err(~"can't do this op on an int and uint")
             }
           }
           (Ok(const_uint(a)), Ok(const_int(b))) => {
             match op {
               BiShl => Ok(const_uint(a << b)),
               BiShr => Ok(const_uint(a >> b)),
-              _ => Err(~"Can't do this op on a uint and int")
+              _ => Err(~"can't do this op on a uint and int")
             }
           }
           (Ok(const_bool(a)), Ok(const_bool(b))) => {
@@ -442,10 +442,10 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
               BiBitOr => a | b,
               BiEq => a == b,
               BiNe => a != b,
-              _ => return Err(~"Can't do this op on bools")
+              _ => return Err(~"can't do this op on bools")
              }))
           }
-          _ => Err(~"Bad operands for binary")
+          _ => Err(~"bad operands for binary")
         }
       }
       ExprCast(base, target_ty) => {
@@ -456,7 +456,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
                 .or_else(|| astconv::ast_ty_to_prim_ty(tcx.ty_ctxt(), target_ty))
                 .unwrap_or_else(|| tcx.ty_ctxt().sess.span_fatal(
                     target_ty.span,
-                    format!("Target type not found for const cast")
+                    format!("target type not found for const cast")
                 ));
 
         let base = eval_const_expr_partial(tcx, base);
@@ -469,7 +469,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
                             const_uint(u) => Ok(const_float(u as f64)),
                             const_int(i) => Ok(const_float(i as f64)),
                             const_float(f) => Ok(const_float(f)),
-                            _ => Err(~"Can't cast float to str"),
+                            _ => Err(~"can't cast float to str"),
                         }
                     }
                     ty::ty_uint(_) => {
@@ -477,7 +477,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
                             const_uint(u) => Ok(const_uint(u)),
                             const_int(i) => Ok(const_uint(i as u64)),
                             const_float(f) => Ok(const_uint(f as u64)),
-                            _ => Err(~"Can't cast str to uint"),
+                            _ => Err(~"can't cast str to uint"),
                         }
                     }
                     ty::ty_int(_) | ty::ty_bool => {
@@ -485,10 +485,10 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
                             const_uint(u) => Ok(const_int(u as i64)),
                             const_int(i) => Ok(const_int(i)),
                             const_float(f) => Ok(const_int(f as i64)),
-                            _ => Err(~"Can't cast str to int"),
+                            _ => Err(~"can't cast str to int"),
                         }
                     }
-                    _ => Err(~"Can't cast this type")
+                    _ => Err(~"can't cast this type")
                 }
             }
         }
@@ -496,14 +496,14 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
       ExprPath(_) => {
           match lookup_const(tcx.ty_ctxt(), e) {
               Some(actual_e) => eval_const_expr_partial(&tcx.ty_ctxt(), actual_e),
-              None => Err(~"Non-constant path in constant expr")
+              None => Err(~"non-constant path in constant expr")
           }
       }
       ExprLit(lit) => Ok(lit_to_const(lit)),
       // If we have a vstore, just keep going; it has to be a string
       ExprVstore(e, _) => eval_const_expr_partial(tcx, e),
       ExprParen(e)     => eval_const_expr_partial(tcx, e),
-      _ => Err(~"Unsupported constant expr")
+      _ => Err(~"unsupported constant expr")
     }
 }
 
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index 6645450a970..e4b648dd43c 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -879,7 +879,7 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
                             None => {
                                 self.tcx().sess.span_bug(
                                     expr.span,
-                                    format!("No loop scope for id {:?}", loop_id));
+                                    format!("no loop scope for id {:?}", loop_id));
                             }
                         }
                     }
@@ -887,7 +887,7 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
                     r => {
                         self.tcx().sess.span_bug(
                             expr.span,
-                            format!("Bad entry `{:?}` in def_map for label", r));
+                            format!("bad entry `{:?}` in def_map for label", r));
                     }
                 }
             }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 26e4a11ae49..546d6f27204 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -328,7 +328,7 @@ impl IrMaps {
           Some(&var) => var,
           None => {
             self.tcx.sess.span_bug(
-                span, format!("No variable registered for id {}", node_id));
+                span, format!("no variable registered for id {}", node_id));
           }
         }
     }
@@ -627,7 +627,7 @@ impl Liveness {
             // code have to agree about which AST nodes are worth
             // creating liveness nodes for.
             self.tcx.sess.span_bug(
-                span, format!("No live node registered for node {}",
+                span, format!("no live node registered for node {}",
                            node_id));
           }
         }
@@ -759,7 +759,7 @@ impl Liveness {
                 let def_map = self.tcx.def_map.borrow();
                 match def_map.get().find(&id) {
                     Some(&DefLabel(loop_id)) => loop_id,
-                    _ => self.tcx.sess.span_bug(sp, "Label on break/loop \
+                    _ => self.tcx.sess.span_bug(sp, "label on break/loop \
                                                      doesn't refer to a loop")
                 }
             }
@@ -1152,7 +1152,7 @@ impl Liveness {
               match break_ln.get().find(&sc) {
                   Some(&b) => b,
                   None => self.tcx.sess.span_bug(expr.span,
-                                                 "Break to unknown label")
+                                                 "break to unknown label")
               }
           }
 
@@ -1167,7 +1167,7 @@ impl Liveness {
               match cont_ln.get().find(&sc) {
                   Some(&b) => b,
                   None => self.tcx.sess.span_bug(expr.span,
-                                                 "Loop to unknown label")
+                                                 "loop to unknown label")
               }
           }
 
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 7c5d1439edf..f5e3ff5db34 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -548,7 +548,7 @@ impl mem_categorization_ctxt {
                   _ => {
                       self.tcx.sess.span_bug(
                           span,
-                          format!("Upvar of non-closure {:?} - {}",
+                          format!("upvar of non-closure {:?} - {}",
                                fn_node_id, ty.repr(self.tcx)));
                   }
               }
@@ -652,7 +652,7 @@ impl mem_categorization_ctxt {
             None => {
                 self.tcx.sess.span_bug(
                     node.span(),
-                    format!("Explicit deref of non-derefable type: {}",
+                    format!("explicit deref of non-derefable type: {}",
                          ty_to_str(self.tcx, base_cmt.ty)));
             }
         };
@@ -745,7 +745,7 @@ impl mem_categorization_ctxt {
           None => {
             self.tcx.sess.span_bug(
                 elt.span(),
-                format!("Explicit index of non-index type `{}`",
+                format!("explicit index of non-index type `{}`",
                      ty_to_str(self.tcx, base_cmt.ty)));
           }
         };
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 9c11b89bb7e..86de1399acb 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -142,7 +142,7 @@ impl RegionMaps {
         let scope_map = self.scope_map.borrow();
         match scope_map.get().find(&id) {
             Some(&r) => r,
-            None => { fail!("No enclosing scope for id {}", id); }
+            None => { fail!("no enclosing scope for id {}", id); }
         }
     }
 
@@ -154,7 +154,7 @@ impl RegionMaps {
         let var_map = self.var_map.borrow();
         match var_map.get().find(&var_id) {
             Some(&r) => r,
-            None => { fail!("No enclosing scope for id {}", var_id); }
+            None => { fail!("no enclosing scope for id {}", var_id); }
         }
     }
 
@@ -554,7 +554,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
         None => {
             visitor.sess.span_bug(
                 local.span,
-                "Local without enclosing block");
+                "local without enclosing block");
         }
     };
 
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 6ee44c03a80..19e67bb865d 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -1378,7 +1378,7 @@ impl Resolver {
                     }
                     match method_map.get().find_mut(name) {
                         Some(s) => { s.insert(def_id); },
-                        _ => fail!("Can't happen"),
+                        _ => fail!("can't happen"),
                     }
                 }
 
@@ -1696,7 +1696,7 @@ impl Resolver {
                   }
                   match method_map.get().find_mut(name) {
                       Some(s) => { s.insert(def_id); },
-                      _ => fail!("Can't happen"),
+                      _ => fail!("can't happen"),
                   }
               }
 
@@ -3992,7 +3992,7 @@ impl Resolver {
                             self.resolve_error(field.span,
                                 format!("field `{}` is already declared", ident_str));
                             self.session.span_note(prev_field.span,
-                                "Previously declared here");
+                                "previously declared here");
                         },
                         None => {
                             ident_map.insert(ident, field);
@@ -4476,7 +4476,7 @@ impl Resolver {
                                       // in the same disjunct, which is an
                                       // error
                                      self.resolve_error(pattern.span,
-                                       format!("Identifier `{}` is bound more \
+                                       format!("identifier `{}` is bound more \
                                              than once in the same pattern",
                                             path_to_str(path, self.session
                                                         .intr())));
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index ead67f78063..ab730c1b2e5 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -297,7 +297,7 @@ impl LifetimeContext {
                        def: ast::DefRegion) {
         if lifetime_ref.id == ast::DUMMY_NODE_ID {
             self.sess.span_bug(lifetime_ref.span,
-                               "Lifetime reference not renumbered, \
+                               "lifetime reference not renumbered, \
                                probably a bug in syntax::fold");
         }
 
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index ad2e96702b0..f49b0f1af08 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -484,7 +484,7 @@ fn assert_is_binding_or_wild(bcx: &Block, p: @ast::Pat) {
     if !pat_is_binding_or_wild(bcx.tcx().def_map, p) {
         bcx.sess().span_bug(
             p.span,
-            format!("Expected an identifier pattern but found p: {}",
+            format!("expected an identifier pattern but found p: {}",
                  p.repr(bcx.tcx())));
     }
 }
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 9d90fdb8011..15fbb54cd11 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -434,7 +434,7 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool
                                  Type::array(&Type::i64(), align_units),
                 a if a.population_count() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
                                                               align_units),
-                _ => fail!("Unsupported enum alignment: {:?}", align)
+                _ => fail!("unsupported enum alignment: {:?}", align)
             };
             assert_eq!(machine::llalign_of_min(cx, pad_ty) as u64, align);
             assert_eq!(align % discr_size, 0);
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index 80d92d85686..77fe847f5f2 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -103,7 +103,7 @@ fn trans<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> {
             _ => {
                 bcx.tcx().sess.span_bug(
                     expr.span,
-                    format!("Type of callee is neither bare-fn nor closure: {}",
+                    format!("type of callee is neither bare-fn nor closure: {}",
                          bcx.ty_to_str(datum.ty)));
             }
         }
@@ -151,7 +151,7 @@ fn trans<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> {
             ast::DefSelfTy(..) | ast::DefMethod(..) => {
                 bcx.tcx().sess.span_bug(
                     ref_expr.span,
-                    format!("Cannot translate def {:?} \
+                    format!("cannot translate def {:?} \
                           to a callable thing!", def));
             }
         }
diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs
index acbbdf27d1c..e28660ea01f 100644
--- a/src/librustc/middle/trans/cleanup.rs
+++ b/src/librustc/middle/trans/cleanup.rs
@@ -211,7 +211,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
                 _ => {}
             }
         }
-        self.ccx.tcx.sess.bug("No loop scope found");
+        self.ccx.tcx.sess.bug("no loop scope found");
     }
 
     fn normal_exit_block(&'a self,
@@ -337,7 +337,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
         }
 
         self.ccx.tcx.sess.bug(
-            format!("No cleanup scope {} found",
+            format!("no cleanup scope {} found",
                     ast_map::node_id_to_str(self.ccx.tcx.items, cleanup_scope,
                                             token::get_ident_interner())));
     }
@@ -548,7 +548,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> {
 
                     LoopExit(id, _) => {
                         self.ccx.tcx.sess.bug(format!(
-                                "Cannot exit from scope {:?}, \
+                                "cannot exit from scope {:?}, \
                                 not in scope", id));
                     }
                 }
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 7ee77e4c0d6..7dbf159265d 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -472,7 +472,7 @@ impl<'a> Block<'a> {
             Some(&v) => v,
             None => {
                 self.tcx().sess.bug(format!(
-                    "No def associated with node id {:?}", nid));
+                    "no def associated with node id {:?}", nid));
             }
         }
     }
@@ -852,7 +852,7 @@ pub fn node_id_type_params(bcx: &Block, id: ast::NodeId) -> ~[ty::t] {
 
     if !params.iter().all(|t| !ty::type_needs_infer(*t)) {
         bcx.sess().bug(
-            format!("Type parameters for node {} include inference types: {}",
+            format!("type parameters for node {} include inference types: {}",
                  id, params.map(|t| bcx.ty_to_str(*t)).connect(",")));
     }
 
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index a8b0da80266..760c56dd945 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -146,14 +146,14 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
                     const_deref_newtype(cx, v, t)
                 }
                 _ => {
-                    cx.sess.bug(format!("Unexpected dereferenceable type {}",
+                    cx.sess.bug(format!("unexpected dereferenceable type {}",
                                      ty_to_str(cx.tcx, t)))
                 }
             };
             (dv, mt.ty)
         }
         None => {
-            cx.sess.bug(format!("Can't dereference const of type {}",
+            cx.sess.bug(format!("can't dereference const of type {}",
                              ty_to_str(cx.tcx, t)))
         }
     }
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index 7bbbf4f9905..d214a192ed8 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -298,7 +298,7 @@ pub fn create_local_var_metadata(bcx: &Block, local: &ast::Local) {
                 Some(datum) => datum,
                 None => {
                     bcx.tcx().sess.span_bug(span,
-                        format!("No entry in lllocals table for {:?}",
+                        format!("no entry in lllocals table for {:?}",
                                 node_id));
                 }
             }
@@ -440,7 +440,7 @@ pub fn create_argument_metadata(bcx: &Block, arg: &ast::Arg) {
                 Some(v) => v,
                 None => {
                     bcx.tcx().sess.span_bug(span,
-                        format!("No entry in llargs table for {:?}",
+                        format!("no entry in llargs table for {:?}",
                                 node_id));
                 }
             }
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index bc9dd767ec6..cb638e99ab7 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -81,17 +81,17 @@ pub fn llvm_calling_convention(ccx: &CrateContext,
         match abi {
             RustIntrinsic => {
                 // Intrinsics are emitted by monomorphic fn
-                ccx.sess.bug(format!("Asked to register intrinsic fn"));
+                ccx.sess.bug(format!("asked to register intrinsic fn"));
             }
 
             Rust => {
                 // FIXME(#3678) Implement linking to foreign fns with Rust ABI
                 ccx.sess.unimpl(
-                    format!("Foreign functions with Rust ABI"));
+                    format!("foreign functions with Rust ABI"));
             }
 
             // It's the ABI's job to select this, not us.
-            System => ccx.sess.bug("System abi should be selected elsewhere"),
+            System => ccx.sess.bug("system abi should be selected elsewhere"),
 
             Stdcall => lib::llvm::X86StdcallCallConv,
             Fastcall => lib::llvm::X86FastcallCallConv,
@@ -365,7 +365,7 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
                             (abis, (*path).clone())
                         }
                         _ => {
-                            fail!("Unable to find foreign item in tcx.items \
+                            fail!("unable to find foreign item in tcx.items \
                                    table.")
                         }
                     };
diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs
index 25ecbeaa9a5..653f56c6de3 100644
--- a/src/librustc/middle/trans/intrinsic.rs
+++ b/src/librustc/middle/trans/intrinsic.rs
@@ -227,7 +227,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 "acq"     => lib::llvm::Acquire,
                 "rel"     => lib::llvm::Release,
                 "acqrel"  => lib::llvm::AcquireRelease,
-                _ => ccx.sess.fatal("Unknown ordering in atomic intrinsic")
+                _ => ccx.sess.fatal("unknown ordering in atomic intrinsic")
             }
         };
 
@@ -268,7 +268,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                     "min"   => lib::llvm::Min,
                     "umax"  => lib::llvm::UMax,
                     "umin"  => lib::llvm::UMin,
-                    _ => ccx.sess.fatal("Unknown atomic operation")
+                    _ => ccx.sess.fatal("unknown atomic operation")
                 };
 
                 let old = AtomicRMW(bcx, atom_op, get_param(decl, first_real_arg),
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 25c536f2a6d..61100220ffb 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -98,7 +98,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         session::expect(
             ccx.sess,
             ccx.tcx.items.find(fn_id.node),
-            || format!("While monomorphizing {:?}, couldn't find it in the \
+            || format!("while monomorphizing {:?}, couldn't find it in the \
                         item map (may have attempted to monomorphize an item \
                         defined in a different crate?)", fn_id))
     };
@@ -286,7 +286,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
                     d
                 }
                 _ => {
-                    ccx.tcx.sess.bug(format!("Can't monomorphize a {:?}",
+                    ccx.tcx.sess.bug(format!("can't monomorphize a {:?}",
                                              map_node))
                 }
             }
@@ -310,7 +310,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         ast_map::NodeBlock(..) |
         ast_map::NodeCalleeScope(..) |
         ast_map::NodeLocal(..) => {
-            ccx.tcx.sess.bug(format!("Can't monomorphize a {:?}", map_node))
+            ccx.tcx.sess.bug(format!("can't monomorphize a {:?}", map_node))
         }
     };
 
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index 8c2047a5fc5..1a1ae97bbcd 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -95,7 +95,7 @@ impl<'a> Reflector<'a> {
         let tcx = self.bcx.tcx();
         let mth_idx = ty::method_idx(
             tcx.sess.ident_of(~"visit_" + ty_name),
-            *self.visitor_methods).expect(format!("Couldn't find visit method \
+            *self.visitor_methods).expect(format!("couldn't find visit method \
                                                 for {}", ty_name));
         let mth_ty =
             ty::mk_bare_fn(tcx, self.visitor_methods[mth_idx].fty.clone());
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
index a0a1ff20a9a..c8180362bc5 100644
--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@@ -404,7 +404,7 @@ pub fn write_content<'a>(
                 }
                 _ => {
                     bcx.tcx().sess.span_bug(content_expr.span,
-                                            "Unexpected evec content");
+                                            "unexpected evec content");
                 }
             }
         }
@@ -465,7 +465,7 @@ pub fn write_content<'a>(
         }
         _ => {
             bcx.tcx().sess.span_bug(content_expr.span,
-                                    "Unexpected vec content");
+                                    "unexpected vec content");
         }
     }
 }
@@ -498,7 +498,7 @@ pub fn elements_required(bcx: &Block, content_expr: &ast::Expr) -> uint {
                 ast::LitStr(ref s, _) => s.get().len(),
                 _ => {
                     bcx.tcx().sess.span_bug(content_expr.span,
-                                            "Unexpected evec content")
+                                            "unexpected evec content")
                 }
             }
         },
@@ -507,7 +507,7 @@ pub fn elements_required(bcx: &Block, content_expr: &ast::Expr) -> uint {
             ty::eval_repeat_count(&bcx.tcx(), count_expr)
         }
         _ => bcx.tcx().sess.span_bug(content_expr.span,
-                                     "Unexpected vec content")
+                                     "unexpected vec content")
     }
 }
 
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 1ff6da63fea..7b2aee9274a 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2101,7 +2101,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
             ty_type => TC::None,
 
             ty_err => {
-                cx.sess.bug("Asked to compute contents of error type");
+                cx.sess.bug("asked to compute contents of error type");
             }
         };
 
@@ -2926,7 +2926,7 @@ pub fn adjust_ty(cx: ctxt,
                                 None => {
                                     cx.sess.span_bug(
                                         span,
-                                        format!("The {}th autoderef failed: \
+                                        format!("the {}th autoderef failed: \
                                                 {}",
                                                 i,
                                                 ty_to_str(cx, adjusted_ty)));
@@ -3132,7 +3132,7 @@ pub fn resolve_expr(tcx: ctxt, expr: &ast::Expr) -> ast::Def {
         Some(&def) => def,
         None => {
             tcx.sess.span_bug(expr.span, format!(
-                "No def-map entry for expr {:?}", expr.id));
+                "no def-map entry for expr {:?}", expr.id));
         }
     }
 }
@@ -3209,7 +3209,7 @@ pub fn expr_kind(tcx: ctxt,
 
                 def => {
                     tcx.sess.span_bug(expr.span, format!(
-                        "Uncategorized def for expr {:?}: {:?}",
+                        "uncategorized def for expr {:?}: {:?}",
                         expr.id, def));
                 }
             }
@@ -3335,7 +3335,7 @@ pub fn field_idx_strict(tcx: ty::ctxt, name: ast::Name, fields: &[field])
     for f in fields.iter() { if f.ident.name == name { return i; } i += 1u; }
     let string = token::get_ident(name);
     tcx.sess.bug(format!(
-        "No field named `{}` found in the list of fields `{:?}`",
+        "no field named `{}` found in the list of fields `{:?}`",
         string.get(),
         fields.map(|f| tcx.sess.str_of(f.ident))));
 }
@@ -3687,7 +3687,7 @@ fn lookup_locally_or_in_crate_store<V:Clone>(
     }
 
     if def_id.crate == ast::LOCAL_CRATE {
-        fail!("No def'n found for {:?} in tcx.{}", def_id, descr);
+        fail!("no def'n found for {:?} in tcx.{}", def_id, descr);
     }
     let v = load_external();
     map.insert(def_id, v.clone());
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 2463bf679d0..f19ca049368 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -789,7 +789,7 @@ impl<'a> LookupContext<'a> {
             ty_err => None,
 
             ty_unboxed_vec(_) | ty_type | ty_infer(TyVar(_)) => {
-                self.bug(format!("Unexpected type: {}",
+                self.bug(format!("unexpected type: {}",
                               self.ty_to_str(self_ty)));
             }
         }
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 81948464d53..2332152a5d7 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -517,9 +517,9 @@ pub fn check_no_duplicate_fields(tcx: ty::ctxt,
         let orig_sp = field_names.find(&id).map(|x| *x);
         match orig_sp {
             Some(orig_sp) => {
-                tcx.sess.span_err(sp, format!("Duplicate field name {} in record type declaration",
+                tcx.sess.span_err(sp, format!("duplicate field name {} in record type declaration",
                                               tcx.sess.str_of(id)));
-                tcx.sess.span_note(orig_sp, "First declaration of this field occurred here");
+                tcx.sess.span_note(orig_sp, "first declaration of this field occurred here");
                 break;
             }
             None => {
@@ -1006,7 +1006,7 @@ impl FnCtxt {
             None => {
                 self.tcx().sess.span_bug(
                     span,
-                    format!("No type for local variable {:?}", nid));
+                    format!("no type for local variable {:?}", nid));
             }
         }
     }
@@ -1619,7 +1619,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                 _ => {
                     fcx.tcx().sess.span_bug(
                         sp,
-                        format!("Method without bare fn type"));
+                        format!("method without bare fn type"));
                 }
             }
         }
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 1a45a1d5491..ac15d52ff13 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -473,7 +473,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
         _ => {
             tcx.sess.span_bug(
                 expr.span,
-                "Expected expr_fn_block");
+                "expected expr_fn_block");
         }
     }
 }
@@ -1189,7 +1189,7 @@ pub mod guarantor {
                 None => {
                     tcx.sess.span_bug(
                         expr.span,
-                        format!("Autoderef but type not derefable: {}",
+                        format!("autoderef but type not derefable: {}",
                              ty_to_str(tcx, ct.ty)));
                 }
             }
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index c1a6e53069e..5e46daad7ee 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -430,7 +430,7 @@ pub fn ensure_supertraits(ccx: &CrateCtxt,
             if ty_trait_refs.iter().any(|other_trait| other_trait.def_id == trait_ref.def_id) {
                 // This means a trait inherited from the same supertrait more
                 // than once.
-                tcx.sess.span_err(sp, "Duplicate supertrait in trait declaration");
+                tcx.sess.span_err(sp, "duplicate supertrait in trait declaration");
                 break;
             } else {
                 ty_trait_refs.push(trait_ref);
@@ -891,7 +891,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
         ast::ItemTrait(..) => {
             tcx.sess.span_bug(
                 it.span,
-                format!("Invoked ty_of_item on trait"));
+                format!("invoked ty_of_item on trait"));
         }
         ast::ItemStruct(_, ref generics) => {
             let ty_generics = ty_generics(ccx, generics, 0);
diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs
index 0db17c8148e..d8166108947 100644
--- a/src/librustc/middle/typeck/infer/coercion.rs
+++ b/src/librustc/middle/typeck/infer/coercion.rs
@@ -202,7 +202,7 @@ impl<'f> Coerce<'f> {
             Err(e) => {
                 self.get_ref().infcx.tcx.sess.span_bug(
                     self.get_ref().trace.origin.span(),
-                    format!("Failed to resolve even without \
+                    format!("failed to resolve even without \
                           any force options: {:?}", e));
             }
         }
diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs
index d96cf84eb13..fa40fa6a064 100644
--- a/src/librustc/middle/typeck/infer/lattice.rs
+++ b/src/librustc/middle/typeck/infer/lattice.rs
@@ -528,7 +528,7 @@ pub fn var_ids<T:Combine>(this: &T,
             r => {
                 this.infcx().tcx.sess.span_bug(
                     this.trace().origin.span(),
-                    format!("Found non-region-vid: {:?}", r));
+                    format!("found non-region-vid: {:?}", r));
             }
         }).collect()
 }
diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs
index 54998e06f8e..2bc0d7d6419 100644
--- a/src/librustc/middle/typeck/infer/region_inference/mod.rs
+++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs
@@ -233,7 +233,7 @@ impl RegionVarBindings {
         self.bound_count.set(sc + 1);
 
         if sc >= self.bound_count.get() {
-            self.tcx.sess.bug("Rollover in RegionInference new_bound()");
+            self.tcx.sess.bug("rollover in RegionInference new_bound()");
         }
 
         ReLateBound(binder_id, BrFresh(sc))
@@ -278,7 +278,7 @@ impl RegionVarBindings {
           (_, ReLateBound(..)) => {
             self.tcx.sess.span_bug(
                 origin.span(),
-                format!("Cannot relate bound region: {} <= {}",
+                format!("cannot relate bound region: {} <= {}",
                         sub.repr(self.tcx),
                         sup.repr(self.tcx)));
           }
@@ -351,7 +351,7 @@ impl RegionVarBindings {
                 let var_origins = self.var_origins.borrow();
                 self.tcx.sess.span_bug(
                     var_origins.get()[rid.to_uint()].span(),
-                    format!("Attempt to resolve region variable before \
+                    format!("attempt to resolve region variable before \
                              values have been computed!"))
             }
             Some(ref values) => values[rid.to_uint()]
@@ -544,7 +544,7 @@ impl RegionVarBindings {
           (ReEarlyBound(..), _) |
           (_, ReEarlyBound(..)) => {
             self.tcx.sess.bug(
-                format!("Cannot relate bound region: LUB({}, {})",
+                format!("cannot relate bound region: LUB({}, {})",
                         a.repr(self.tcx),
                         b.repr(self.tcx)));
           }
@@ -646,7 +646,7 @@ impl RegionVarBindings {
             (ReEarlyBound(..), _) |
             (_, ReEarlyBound(..)) => {
               self.tcx.sess.bug(
-                  format!("Cannot relate bound region: GLB({}, {})",
+                  format!("cannot relate bound region: GLB({}, {})",
                           a.repr(self.tcx),
                           b.repr(self.tcx)));
             }
diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs
index dd96018d4af..517fe232b03 100644
--- a/src/librustc/middle/typeck/infer/test.rs
+++ b/src/librustc/middle/typeck/infer/test.rs
@@ -97,7 +97,7 @@ impl Env {
         return match search_mod(self, &self.crate.node.module, 0, names) {
             Some(id) => id,
             None => {
-                fail!("No item found: `%s`", names.connect("::"));
+                fail!("no item found: `%s`", names.connect("::"));
             }
         };
 
@@ -230,7 +230,7 @@ impl Env {
             for msg in self.err_messages.iter() {
                 debug!("Error encountered: %s", *msg);
             }
-            format!("Resolving regions encountered %u errors but expected %u!",
+            format!("resolving regions encountered %u errors but expected %u!",
                  self.err_messages.len(),
                  exp_count);
         }
@@ -240,7 +240,7 @@ impl Env {
     pub fn check_lub(&self, t1: ty::t, t2: ty::t, t_lub: ty::t) {
         match self.lub().tys(t1, t2) {
             Err(e) => {
-                fail!("Unexpected error computing LUB: %?", e)
+                fail!("unexpected error computing LUB: %?", e)
             }
             Ok(t) => {
                 self.assert_eq(t, t_lub);
@@ -262,7 +262,7 @@ impl Env {
                self.ty_to_str(t_glb));
         match self.glb().tys(t1, t2) {
             Err(e) => {
-                fail!("Unexpected error computing LUB: %?", e)
+                fail!("unexpected error computing LUB: %?", e)
             }
             Ok(t) => {
                 self.assert_eq(t, t_glb);
@@ -281,7 +281,7 @@ impl Env {
         match self.lub().tys(t1, t2) {
             Err(_) => {}
             Ok(t) => {
-                fail!("Unexpected success computing LUB: %?", self.ty_to_str(t))
+                fail!("unexpected success computing LUB: %?", self.ty_to_str(t))
             }
         }
     }
@@ -291,7 +291,7 @@ impl Env {
         match self.glb().tys(t1, t2) {
             Err(_) => {}
             Ok(t) => {
-                fail!("Unexpected success computing GLB: %?", self.ty_to_str(t))
+                fail!("unexpected success computing GLB: %?", self.ty_to_str(t))
             }
         }
     }
diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs
index 51364addfed..e29add4bc95 100644
--- a/src/librustc/middle/typeck/variance.rs
+++ b/src/librustc/middle/typeck/variance.rs
@@ -718,7 +718,7 @@ impl<'a> ConstraintContext<'a> {
             ty::ty_infer(..) | ty::ty_err |
             ty::ty_type | ty::ty_unboxed_vec(..) => {
                 self.tcx().sess.bug(
-                    format!("Unexpected type encountered in \
+                    format!("unexpected type encountered in \
                             variance inference: {}",
                             ty.repr(self.tcx())));
             }
@@ -804,7 +804,7 @@ impl<'a> ConstraintContext<'a> {
             ty::ReEmpty => {
                 // We don't expect to see anything but 'static or bound
                 // regions when visiting member types or method types.
-                self.tcx().sess.bug(format!("Unexpected region encountered in \
+                self.tcx().sess.bug(format!("unexpected region encountered in \
                                             variance inference: {}",
                                             region.repr(self.tcx())));
             }
diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs
index 74fefe41683..5fbf57c5060 100644
--- a/src/librustc/util/sha2.rs
+++ b/src/librustc/util/sha2.rs
@@ -64,12 +64,12 @@ fn add_bytes_to_bits<T: Int + CheckedAdd + ToBits>(bits: T, bytes: T) -> T {
     let (new_high_bits, new_low_bits) = bytes.to_bits();
 
     if new_high_bits > Zero::zero() {
-        fail!("Numeric overflow occured.")
+        fail!("numeric overflow occured.")
     }
 
     match bits.checked_add(&new_low_bits) {
         Some(x) => return x,
-        None => fail!("Numeric overflow occured.")
+        None => fail!("numeric overflow occured.")
     }
 }
 
diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
index 9194acfcdec..6b0f2c6e516 100644
--- a/src/libsyntax/abi.rs
+++ b/src/libsyntax/abi.rs
@@ -323,7 +323,7 @@ fn cannot_combine(n: Abi, m: Abi) {
                          (m == a && n == b));
         }
         None => {
-            fail!("Invalid match not detected");
+            fail!("invalid match not detected");
         }
     }
 }
@@ -335,7 +335,7 @@ fn can_combine(n: Abi, m: Abi) {
     set.add(m);
     match set.check_valid() {
         Some((_, _)) => {
-            fail!("Valid match declared invalid");
+            fail!("valid match declared invalid");
         }
         None => {}
     }
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
index 6852a0cec33..39bb870b969 100644
--- a/src/libsyntax/ext/bytes.rs
+++ b/src/libsyntax/ext/bytes.rs
@@ -40,7 +40,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
                 // u8 literal, push to vector expression
                 ast::LitUint(v, ast::TyU8) => {
                     if v > 0xFF {
-                        cx.span_err(expr.span, "Too large u8 literal in bytes!")
+                        cx.span_err(expr.span, "too large u8 literal in bytes!")
                     } else {
                         bytes.push(cx.expr_u8(expr.span, v as u8));
                     }
@@ -49,9 +49,9 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
                 // integer literal, push to vector expression
                 ast::LitIntUnsuffixed(v) => {
                     if v > 0xFF {
-                        cx.span_err(expr.span, "Too large integer literal in bytes!")
+                        cx.span_err(expr.span, "too large integer literal in bytes!")
                     } else if v < 0 {
-                        cx.span_err(expr.span, "Negative integer literal in bytes!")
+                        cx.span_err(expr.span, "negative integer literal in bytes!")
                     } else {
                         bytes.push(cx.expr_u8(expr.span, v as u8));
                     }
@@ -62,14 +62,14 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
                     if char::from_u32(v).unwrap().is_ascii() {
                         bytes.push(cx.expr_u8(expr.span, v as u8));
                     } else {
-                        cx.span_err(expr.span, "Non-ascii char literal in bytes!")
+                        cx.span_err(expr.span, "non-ascii char literal in bytes!")
                     }
                 }
 
-                _ => cx.span_err(expr.span, "Unsupported literal in bytes!")
+                _ => cx.span_err(expr.span, "unsupported literal in bytes!")
             },
 
-            _ => cx.span_err(expr.span, "Non-literal in bytes!")
+            _ => cx.span_err(expr.span, "non-literal in bytes!")
         }
     }
 
diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index 17361240628..d911208e7de 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -92,10 +92,10 @@ fn cs_clone(
             all_fields = af;
         },
         EnumNonMatching(..) => cx.span_bug(trait_span,
-                                           format!("Non-matching enum variants in `deriving({})`",
+                                           format!("non-matching enum variants in `deriving({})`",
                                                   name)),
         StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span,
-                                                         format!("Static method in `deriving({})`",
+                                                         format!("static method in `deriving({})`",
                                                                  name))
     }
 
diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs
index 83f623e3066..c06b4e30e07 100644
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@@ -75,7 +75,7 @@ fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt, span: Span, substr: &Substru
             */
             let other_f = match other_fs {
                 [o_f] => o_f,
-                _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
+                _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
             };
 
             let cmp = cx.expr_binary(span, op, self_f, other_f);
@@ -99,7 +99,7 @@ fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt, span: Span, substr: &Substru
                                  } else {
                                      self_var > other_var
                                  }),
-                _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
+                _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
             }
         },
         cx, span, substr)
diff --git a/src/libsyntax/ext/deriving/cmp/totalord.rs b/src/libsyntax/ext/deriving/cmp/totalord.rs
index 27a766c0e75..68de158e9e7 100644
--- a/src/libsyntax/ext/deriving/cmp/totalord.rs
+++ b/src/libsyntax/ext/deriving/cmp/totalord.rs
@@ -110,7 +110,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
                     let order = ordering_const(cx, span, self_var.cmp(&other_var));
                     cx.expr_path(order)
                 }
-                _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(TotalOrd)`")
+                _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(TotalOrd)`")
             }
         },
         cx, span, substr)
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 8c06f0b8c8a..01006a0c15d 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -656,7 +656,7 @@ impl<'a> MethodDef<'a> {
                 }).collect()
             }
             [] => { trait_.cx.span_bug(trait_.span,
-                                       "No self arguments to non-static method \
+                                       "no self arguments to non-static method \
                                        in generic `deriving`") }
         };
 
@@ -840,7 +840,7 @@ impl<'a> MethodDef<'a> {
                 let index = match matching {
                     Some(i) => i,
                     None => cx.span_bug(trait_.span,
-                                        "Non-matching variants when required to \
+                                        "non-matching variants when required to \
                                         be matching in generic `deriving`")
                 };
 
@@ -965,7 +965,7 @@ impl<'a> TraitDef<'a> {
 
         match (just_spans.is_empty(), named_idents.is_empty()) {
             (false, false) => self.cx.span_bug(self.span,
-                                               "A struct with named and unnamed \
+                                               "a struct with named and unnamed \
                                                fields in generic `deriving`"),
             // named fields
             (_, false) => Named(named_idents),
@@ -1019,7 +1019,7 @@ impl<'a> TraitDef<'a> {
                     None
                 }
                 _ => {
-                    cx.span_bug(sp, "A struct with named and unnamed fields in `deriving`");
+                    cx.span_bug(sp, "a struct with named and unnamed fields in `deriving`");
                 }
             };
             let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i)));
@@ -1116,7 +1116,7 @@ pub fn cs_fold(use_foldl: bool,
                                                           *all_enums,
                                                           substructure.nonself_args),
         StaticEnum(..) | StaticStruct(..) => {
-            cx.span_bug(trait_span, "Static function in `deriving`")
+            cx.span_bug(trait_span, "static function in `deriving`")
         }
     }
 }
@@ -1154,7 +1154,7 @@ pub fn cs_same_method(f: |&mut ExtCtxt, Span, ~[@Expr]| -> @Expr,
                                                           *all_enums,
                                                           substructure.nonself_args),
         StaticEnum(..) | StaticStruct(..) => {
-            cx.span_bug(trait_span, "Static function in `deriving`")
+            cx.span_bug(trait_span, "static function in `deriving`")
         }
     }
 }
diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs
index 53805694725..5f680745ea7 100644
--- a/src/libsyntax/ext/deriving/iter_bytes.rs
+++ b/src/libsyntax/ext/deriving/iter_bytes.rs
@@ -48,7 +48,7 @@ pub fn expand_deriving_iter_bytes(cx: &mut ExtCtxt,
 fn iter_bytes_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
     let (lsb0, f)= match substr.nonself_args {
         [l, f] => (l, f),
-        _ => cx.span_bug(trait_span, "Incorrect number of arguments in `deriving(IterBytes)`")
+        _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(IterBytes)`")
     };
     // Build the "explicitly borrowed" stack closure, "|_buf| f(_buf)".
     let blk_arg = cx.ident_of("_buf");
@@ -82,7 +82,7 @@ fn iter_bytes_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substruc
 
             fields = fs;
         }
-        _ => cx.span_bug(trait_span, "Impossible substructure in `deriving(IterBytes)`")
+        _ => cx.span_bug(trait_span, "impossible substructure in `deriving(IterBytes)`")
     }
 
     for &FieldInfo { self_, span, .. } in fields.iter() {
diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs
index 86c46705d81..f74b807bae6 100644
--- a/src/libsyntax/ext/deriving/primitive.rs
+++ b/src/libsyntax/ext/deriving/primitive.rs
@@ -68,7 +68,7 @@ pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
 fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
     let n = match substr.nonself_args {
         [n] => n,
-        _ => cx.span_bug(trait_span, "Incorrect number of arguments in `deriving(FromPrimitive)`")
+        _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
     };
 
     match *substr.fields {
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index f37abbe1ef4..ff0fd388ebe 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -178,8 +178,8 @@ impl<'a> Ty<'a> {
             Literal(ref p) => {
                 p.to_path(cx, span, self_ty, self_generics)
             }
-            Ptr(..) => { cx.span_bug(span, "Pointer in a path in generic `deriving`") }
-            Tuple(..) => { cx.span_bug(span, "Tuple in a path in generic `deriving`") }
+            Ptr(..) => { cx.span_bug(span, "pointer in a path in generic `deriving`") }
+            Tuple(..) => { cx.span_bug(span, "tuple in a path in generic `deriving`") }
         }
     }
 }
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index bd1ac616f52..e9832209904 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -257,7 +257,7 @@ pub mod rt {
             match res {
                 Some(ast) => ast,
                 None => {
-                    error!("Parse error");
+                    error!("parse error");
                     fail!()
                 }
             }
@@ -589,7 +589,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
     let cx_expr = p.parse_expr();
     if !p.eat(&token::COMMA) {
-        p.fatal("Expected token `,`");
+        p.fatal("expected token `,`");
     }
 
     let tts = p.parse_all_token_trees();
diff --git a/src/libsyntax/ext/registrar.rs b/src/libsyntax/ext/registrar.rs
index 1c349c4343a..e831e8fbb10 100644
--- a/src/libsyntax/ext/registrar.rs
+++ b/src/libsyntax/ext/registrar.rs
@@ -49,7 +49,7 @@ pub fn find_macro_registrar(diagnostic: @diagnostic::SpanHandler,
             })
         },
         _ => {
-            diagnostic.handler().err("Multiple macro registration functions found");
+            diagnostic.handler().err("multiple macro registration functions found");
             for &(_, span) in ctx.registrars.iter() {
                 diagnostic.span_note(span, "one is here");
             }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index a18f80ad4c9..92bc204e2c1 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -185,7 +185,7 @@ pub fn nameize(p_s: @ParseSess, ms: &[Matcher], res: &[@NamedMatch])
             if ret_val.contains_key(bind_name) {
                 let string = token::get_ident(bind_name.name);
                 p_s.span_diagnostic
-                   .span_fatal(sp, "Duplicated bind name: " + string.get())
+                   .span_fatal(sp, "duplicated bind name: " + string.get())
             }
             ret_val.insert(*bind_name, res[idx]);
           }
@@ -441,6 +441,6 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
         res
       }
       "matchers" => token::NtMatchers(p.parse_matchers()),
-      _ => p.fatal(~"Unsupported builtin nonterminal parser: " + name)
+      _ => p.fatal(~"unsupported builtin nonterminal parser: " + name)
     }
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 430bd02119a..fccbc57f12c 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -148,7 +148,7 @@ fn lis_merge(lhs: LockstepIterSize, rhs: LockstepIterSize) -> LockstepIterSize {
             LisConstraint(r_len, ref r_id) => {
                 let l_n = token::get_ident(l_id.name);
                 let r_n = token::get_ident(r_id.name);
-                LisContradiction(format!("Inconsistent lockstep iteration: \
+                LisContradiction(format!("inconsistent lockstep iteration: \
                                           '{}' has {} items, but '{}' has {}",
                                           l_n.get(), l_len, r_n.get(), r_len))
             }
diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs
index c575e170bef..21f05fa684a 100644
--- a/src/libsyntax/opt_vec.rs
+++ b/src/libsyntax/opt_vec.rs
@@ -85,7 +85,7 @@ impl<T> OptVec<T> {
 
     pub fn get<'a>(&'a self, i: uint) -> &'a T {
         match *self {
-            Empty => fail!("Invalid index {}", i),
+            Empty => fail!("invalid index {}", i),
             Vec(ref v) => &v[i]
         }
     }
@@ -103,7 +103,7 @@ impl<T> OptVec<T> {
 
     pub fn swap_remove(&mut self, index: uint) {
         match *self {
-            Empty => { fail!("Index out of bounds"); }
+            Empty => { fail!("index out of bounds"); }
             Vec(ref mut v) => {
                 assert!(index < v.len());
                 v.swap_remove(index);
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index b85d89cf804..091fbf82b0d 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -76,7 +76,7 @@ impl ParserObsoleteMethods for Parser {
         let (kind_str, desc) = match kind {
             ObsoleteSwap => (
                 "swap",
-                "Use std::util::{swap, replace} instead"
+                "use std::util::{swap, replace} instead"
             ),
             ObsoleteUnsafeBlock => (
                 "non-standalone unsafe block",
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 93574f4d858..fd8b945a177 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -431,7 +431,7 @@ impl Parser {
             && self.look_ahead(1, |t| *t == token::RBRACE) {
             // matched; signal non-fatal error and recover.
             self.span_err(self.span,
-                          "Unit-like struct construction is written with no trailing `{ }`");
+                          "unit-like struct construction is written with no trailing `{ }`");
             self.eat(&token::LBRACE);
             self.eat(&token::RBRACE);
             true
@@ -1601,7 +1601,7 @@ impl Parser {
                 };
             }
             _ => {
-                self.fatal(format!("Expected a lifetime name"));
+                self.fatal(format!("expected a lifetime name"));
             }
         }
     }
@@ -2137,7 +2137,7 @@ impl Parser {
                 }
                 // There shouldn't really be a span, but it's easier for the test runner
                 // if we give it one
-                self.fatal("This file contains an un-closed delimiter ");
+                self.fatal("this file contains an un-closed delimiter ");
             }
             token::LPAREN | token::LBRACE | token::LBRACKET => {
                 let close_delim = token::flip_delimiter(&self.token);
@@ -3957,7 +3957,7 @@ impl Parser {
             }
             if fields.len() == 0 {
                 let string = get_ident_interner().get(class_name.name);
-                self.fatal(format!("Unit-like struct definition should be written as `struct {};`",
+                self.fatal(format!("unit-like struct definition should be written as `struct {};`",
                                    string.as_slice()));
             }
             self.bump();
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 6803bb1eaf9..f6040612961 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -68,7 +68,7 @@ impl<T> SmallVector<T> {
         match *self {
             One(ref v) if idx == 0 => v,
             Many(ref vs) => &vs[idx],
-            _ => fail!("Out of bounds access")
+            _ => fail!("out of bounds access")
         }
     }
 
diff --git a/src/test/compile-fail/issue-2354.rs b/src/test/compile-fail/issue-2354.rs
index 9761bd3317c..a2bb56fdf5f 100644
--- a/src/test/compile-fail/issue-2354.rs
+++ b/src/test/compile-fail/issue-2354.rs
@@ -19,4 +19,4 @@ fn bar() {
     while (i < 1000) {}
 }
 
-fn main() {} //~ ERROR This file contains an un-closed delimiter
+fn main() {} //~ ERROR this file contains an un-closed delimiter
diff --git a/src/test/compile-fail/issue-3038.rs b/src/test/compile-fail/issue-3038.rs
index d0c7a07859e..691bd3b4211 100644
--- a/src/test/compile-fail/issue-3038.rs
+++ b/src/test/compile-fail/issue-3038.rs
@@ -20,16 +20,16 @@ fn main()
 
     let _z = match g(1, 2) {
       g(x, x) => { info!("{:?}", x + x); }
-      //~^ ERROR Identifier `x` is bound more than once in the same pattern
+      //~^ ERROR identifier `x` is bound more than once in the same pattern
     };
 
     let _z = match i(l(1, 2), m(3, 4)) {
-      i(l(x, _), m(_, x))  //~ ERROR Identifier `x` is bound more than once in the same pattern
+      i(l(x, _), m(_, x))  //~ ERROR identifier `x` is bound more than once in the same pattern
         => { error!("{:?}", x + x); }
     };
 
     let _z = match (1, 2) {
-        (x, x) => { x } //~ ERROR Identifier `x` is bound more than once in the same pattern
+        (x, x) => { x } //~ ERROR identifier `x` is bound more than once in the same pattern
     };
 
 }
diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs
index 308a8819355..cfb10d39201 100644
--- a/src/test/compile-fail/issue-3953.rs
+++ b/src/test/compile-fail/issue-3953.rs
@@ -10,7 +10,7 @@
 
 use std::cmp::Eq;
 
-trait Hahaha: Eq + Eq + Eq + Eq + Eq + //~ ERROR Duplicate supertrait
+trait Hahaha: Eq + Eq + Eq + Eq + Eq + //~ ERROR duplicate supertrait
               Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq +
               Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq +
               Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq +
diff --git a/src/test/compile-fail/multiple-macro-registrars.rs b/src/test/compile-fail/multiple-macro-registrars.rs
index 7802c13bd3a..82b1438d6fe 100644
--- a/src/test/compile-fail/multiple-macro-registrars.rs
+++ b/src/test/compile-fail/multiple-macro-registrars.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern: Multiple macro registration functions found
+// error-pattern: multiple macro registration functions found
 
 #[feature(macro_registrar)];
 
diff --git a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
index 52c60971708..2a9a0358cc6 100644
--- a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
+++ b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
@@ -13,6 +13,6 @@
 fn main() {
     fn bar(n: int) {
         let _x: [int, ..n];
-        //~^ ERROR expected constant expr for vector length: Non-constant path in constant expr
+        //~^ ERROR expected constant expr for vector length: non-constant path in constant expr
     }
 }
diff --git a/src/test/compile-fail/struct-no-fields-2.rs b/src/test/compile-fail/struct-no-fields-2.rs
index 63e38e35447..cd555f8d917 100644
--- a/src/test/compile-fail/struct-no-fields-2.rs
+++ b/src/test/compile-fail/struct-no-fields-2.rs
@@ -12,7 +12,7 @@ struct Foo;
 
 fn f2() {
     let _end_stmt     = Foo { };
-    //~^ ERROR: Unit-like struct construction is written with no trailing `{ }`
+    //~^ ERROR: unit-like struct construction is written with no trailing `{ }`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/struct-no-fields-3.rs b/src/test/compile-fail/struct-no-fields-3.rs
index 33077d4f1b3..2595c5e8acf 100644
--- a/src/test/compile-fail/struct-no-fields-3.rs
+++ b/src/test/compile-fail/struct-no-fields-3.rs
@@ -12,7 +12,7 @@ struct Foo;
 
 fn g3() {
     let _mid_tuple    = (Foo { }, 2);
-    //~^ ERROR: Unit-like struct construction is written with no trailing `{ }`
+    //~^ ERROR: unit-like struct construction is written with no trailing `{ }`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/struct-no-fields-4.rs b/src/test/compile-fail/struct-no-fields-4.rs
index 6b73cb769ee..fee5c35e850 100644
--- a/src/test/compile-fail/struct-no-fields-4.rs
+++ b/src/test/compile-fail/struct-no-fields-4.rs
@@ -12,7 +12,7 @@ struct Foo;
 
 fn h4() {
     let _end_of_tuple = (3, Foo { });
-    //~^ ERROR: Unit-like struct construction is written with no trailing `{ }`
+    //~^ ERROR: unit-like struct construction is written with no trailing `{ }`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/struct-no-fields-5.rs b/src/test/compile-fail/struct-no-fields-5.rs
index 81c050e61cb..bd196e881aa 100644
--- a/src/test/compile-fail/struct-no-fields-5.rs
+++ b/src/test/compile-fail/struct-no-fields-5.rs
@@ -12,7 +12,7 @@ struct Foo;
 
 fn i5() {
     let _end_of_block = { Foo { } };
-    //~^ ERROR: Unit-like struct construction is written with no trailing `{ }`
+    //~^ ERROR: unit-like struct construction is written with no trailing `{ }`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/struct-no-fields.rs b/src/test/compile-fail/struct-no-fields.rs
index 6142ec0653c..ee853ade18e 100644
--- a/src/test/compile-fail/struct-no-fields.rs
+++ b/src/test/compile-fail/struct-no-fields.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 struct Foo {}
-//~^ ERROR: Unit-like struct definition should be written as `struct Foo;`
+//~^ ERROR: unit-like struct definition should be written as `struct Foo;`
 
 fn main() {}
diff --git a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs b/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs
index 8bdc643f288..f5b4342ceb7 100644
--- a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!('λ'); //~ ERROR Non-ascii char literal in bytes!
+    let vec = bytes!('λ'); //~ ERROR non-ascii char literal in bytes!
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs b/src/test/compile-fail/syntax-extension-bytes-non-literal.rs
index fed6bdc9470..281a5630f82 100644
--- a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-non-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(foo); //~ ERROR Non-literal in bytes!
+    let vec = bytes!(foo); //~ ERROR non-literal in bytes!
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs
index 8acb280dfde..25688d7d17a 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(1024); //~ ERROR Too large integer literal in bytes!
+    let vec = bytes!(1024); //~ ERROR too large integer literal in bytes!
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs
index b7d69a3054f..d1c8a2c0913 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(1024u8); //~ ERROR Too large u8 literal in bytes!
+    let vec = bytes!(1024u8); //~ ERROR too large u8 literal in bytes!
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs
index cec2dc0a8e0..ef45ea06003 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(-1024); //~ ERROR Non-literal in bytes
+    let vec = bytes!(-1024); //~ ERROR non-literal in bytes
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs
index 2df55a6436c..b8ba73559aa 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(-1024u8); //~ ERROR Non-literal in bytes
+    let vec = bytes!(-1024u8); //~ ERROR non-literal in bytes
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs b/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
index 2d7ff386b7c..142566fe8ab 100644
--- a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
+++ b/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(45f64); //~ ERROR Unsupported literal in bytes!
+    let vec = bytes!(45f64); //~ ERROR unsupported literal in bytes!
 }