---

yaml
---
r: 11628
b: refs/heads/master
c: 0ee96de
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 13a07ce1d4df500d18ce393a7b46775174560d01
+refs/heads/master: 0ee96de4ee21643546908065fbf3bc7a3f436a3f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/rustc/back/link.rs

@@ -439,7 +439,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
                     {
                         let os = str::split_char(fs::basename(output), '.');
                         if (vec::len(os) < 2u) {
-                            sess.fatal(#fmt("Output file name %s doesn't\
+                            sess.fatal(#fmt("output file name %s doesn't\
                               appear to have an extension", output));
                         }
                         vec::pop(os);

trunk/src/rustc/driver/driver.rs

@@ -309,12 +309,12 @@ fn build_target_config(sopts: @session::options,
                        demitter: diagnostic::emitter) -> @session::config {
     let os = alt get_os(sopts.target_triple) {
       some(os) { os }
-      none { early_error(demitter, "Unknown operating system!") }
+      none { early_error(demitter, "unknown operating system") }
     };
     let arch = alt get_arch(sopts.target_triple) {
       some(arch) { arch }
       none { early_error(demitter,
-                          "Unknown architecture! " + sopts.target_triple) }
+                          "unknown architecture: " + sopts.target_triple) }
     };
     let (int_type, uint_type, float_type) = alt arch {
       session::arch_x86 {(ast::ty_i32, ast::ty_u32, ast::ty_f64)}
@@ -607,7 +607,7 @@ fn build_output_filenames(ifile: str,
         }
 
         if odir != none {
-            sess.warn("Ignoring --out-dir flag due to -o flag.");
+            sess.warn("ignoring --out-dir flag due to -o flag.");
         }
       }
     }

trunk/src/rustc/driver/rustc.rs

@@ -93,9 +93,9 @@ fn run_compiler(args: [str], demitter: diagnostic::emitter) {
         ret;
     }
     let ifile = alt vec::len(match.free) {
-      0u { early_error(demitter, "No input filename given.") }
+      0u { early_error(demitter, "o input filename given") }
       1u { match.free[0] }
-      _ { early_error(demitter, "Multiple input filenames provided.") }
+      _ { early_error(demitter, "multiple input filenames provided") }
     };
 
     let sopts = build_session_options(match, demitter);

trunk/src/rustc/metadata/astencode.rs

@@ -823,7 +823,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                                          val_dsr.read_dict_res(xcx));
             } else {
                 xcx.dcx.tcx.sess.bug(
-                    #fmt["Unknown tag found in side tables: %x", tag]);
+                    #fmt["unknown tag found in side tables: %x", tag]);
             }
         }
 

trunk/src/rustc/metadata/creader.rs

@@ -96,7 +96,7 @@ fn list_file_metadata(sess: session::session, path: str, out: io::writer) {
     alt get_metadata_section(sess, path) {
       option::some(bytes) { decoder::list_crate_metadata(bytes, out); }
       option::none {
-        out.write_str("Could not find metadata in " + path + ".\n");
+        out.write_str("could not find metadata in " + path + ".\n");
       }
     }
 }

trunk/src/rustc/middle/capture.rs

@@ -40,15 +40,15 @@ fn check_capture_clause(tcx: ty::ctxt,
         if !vec::any(*freevars, {|fv| fv.def == cap_def}) {
             tcx.sess.span_warn(
                 cap_item.span,
-                #fmt("Captured variable '%s' not used in closure",
+                #fmt("captured variable '%s' not used in closure",
                      cap_item.name));
         }
 
         let cap_def_id = ast_util::def_id_of_def(cap_def).node;
         if !seen_defs.insert(cap_def_id, ()) {
             tcx.sess.span_err(
                 cap_item.span,
-                #fmt("Variable '%s' captured more than once",
+                #fmt("variable '%s' captured more than once",
                      cap_item.name));
         }
     };
@@ -58,7 +58,7 @@ fn check_capture_clause(tcx: ty::ctxt,
           ast::def_upvar(_, _, _) {
             tcx.sess.span_err(
                 cap_item.span,
-                #fmt("Upvars (like '%s') cannot be moved into a closure",
+                #fmt("upvars (like '%s') cannot be moved into a closure",
                      cap_item.name));
           }
           _ {}
@@ -70,7 +70,7 @@ fn check_capture_clause(tcx: ty::ctxt,
             let cap_item0 = vec::head(v);
             tcx.sess.span_err(
                 cap_item0.span,
-                "Cannot capture values explicitly with a block closure");
+                "cannot capture values explicitly with a block closure");
         }
     };
 

trunk/src/rustc/middle/kind.rs

@@ -150,7 +150,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
             let t = ty::expr_ty(cx.tcx, ex);
             let ty_fields = alt ty::get(t).struct {
               ty::ty_rec(f) { f }
-              _ { cx.tcx.sess.span_bug(ex.span, "Bad expr type in record"); }
+              _ { cx.tcx.sess.span_bug(ex.span, "bad expr type in record"); }
             };
             for tf in ty_fields {
                 if !vec::any(fields, {|f| f.node.ident == tf.ident}) &&

trunk/src/rustc/middle/mutbl.rs

@@ -98,7 +98,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
                     is_mutbl = mt.mutbl == m_mutbl;
                     ptr = true;
                   }
-                  _ { tcx.sess.span_bug(base.span, "Ill-typed base \
+                  _ { tcx.sess.span_bug(base.span, "ill-typed base \
                         expression in deref"); }
                 }
                 ds += [@{mutbl: is_mutbl, kind: unbox(ptr && is_mutbl),

trunk/src/rustc/middle/resolve.rs

@@ -329,7 +329,7 @@ fn map_crate(e: @env, c: @ast::crate) {
                         e.mod_map.get(ast::crate_node_id).glob_imports
                             += [glob];
                       }
-                      _ { e.sess.span_bug(vi.span, "Unexpected scope in a \
+                      _ { e.sess.span_bug(vi.span, "unexpected scope in a \
                                                     glob import"); }
                     }
                   }
@@ -376,7 +376,7 @@ fn resolve_imports(e: env) {
             resolve_import(e, local_def(node_id), name, *path, span, scopes);
           }
           resolved(_, _, _, _, _, _) | is_glob(_, _, _) { }
-          _ { e.sess.bug("Shouldn't see a resolving in resolve_imports"); }
+          _ { e.sess.bug("shouldn't see a resolving in resolve_imports"); }
         }
     };
     e.used_imports.track = false;
@@ -658,7 +658,7 @@ fn visit_local_with_scope(e: @env, loc: @local, sc:scopes, v:vt<scopes>) {
                   // Declaration shadows a enum that's in scope.
                   // That's an error.
                   e.sess.span_err(loc.span,
-                    #fmt("Declaration of %s shadows a enum that's in scope",
+                    #fmt("declaration of `%s` shadows a enum that's in scope",
                          path_to_ident(an_ident)));
                   }
               _ {}
@@ -1324,7 +1324,7 @@ fn lookup_in_block(e: env, name: ident, sp: span, b: ast::blk_, pos: uint,
                 }
             }
           }
-          _ { e.sess.span_bug(vi.span, "Unexpected view_item in block"); }
+          _ { e.sess.span_bug(vi.span, "unexpected view_item in block"); }
         }
     }
     ret none;

trunk/src/rustc/middle/trans/alt.rs

@@ -428,7 +428,7 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef], f: mk_fail,
         let tup_ty = node_id_type(bcx, pat_id);
         let n_tup_elts = alt ty::get(tup_ty).struct {
           ty::ty_tup(elts) { elts.len() }
-          _ { ccx.sess.bug("Non-tuple type in tuple pattern"); }
+          _ { ccx.sess.bug("non-tuple type in tuple pattern"); }
         };
         let tup_vals = [], i = 0u;
         while i < n_tup_elts {
@@ -588,7 +588,7 @@ fn make_phi_bindings(bcx: block, map: [exit_node],
             if bcx.ccx().maps.copy_map.contains_key(node_id) {
                 let local = alt bcx.fcx.lllocals.find(node_id) {
                   some(local_mem(x)) { x }
-                  _ { bcx.tcx().sess.bug("Someone \
+                  _ { bcx.tcx().sess.bug("someone \
                         forgot to document an invariant in \
                         make_phi_bindings"); }
                 };

trunk/src/rustc/middle/trans/base.rs

@@ -1957,7 +1957,7 @@ fn trans_if(cx: block, cond: @ast::expr, thn: ast::blk,
             trans_block(else_cx, blk, else_dest)
           }
           // would be nice to have a constraint on ifs
-          _ { cx.tcx().sess.bug("Strange alternative in if"); }
+          _ { cx.tcx().sess.bug("strange alternative in if"); }
         }
       }
       _ { else_cx }
@@ -2119,7 +2119,7 @@ fn monomorphic_fn(ccx: crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
       ast_map::node_method(m, _, pt) { (pt, m.ident) }
       // We can't monomorphize native functions
       ast_map::node_native_item(_, _) { ret none; }
-      _ { fail "Unexpected node type"; }
+      _ { fail "unexpected node type"; }
     };
     let pt = *pt + [path_name(ccx.names(name))];
     let s = mangle_exported_name(ccx, pt, mono_ty);
@@ -2614,10 +2614,10 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
               integral {int_cast(e_res.bcx, ll_t_out,
                                   val_ty(lldiscrim_a), lldiscrim_a, true)}
               float {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)}
-              _ { ccx.sess.bug("Translating unsupported cast.") }
+              _ { ccx.sess.bug("translating unsupported cast.") }
             }
           }
-          _ { ccx.sess.bug("Translating unsupported cast.") }
+          _ { ccx.sess.bug("translating unsupported cast.") }
         };
     ret store_in_dest(e_res.bcx, newval, dest);
 }
@@ -3139,7 +3139,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
                 bcx, proto, decl, body, e.span, e.id, cap_clause, dest);
           }
           _ {
-            fail "Type of fn block is not a function!";
+            fail "type of fn block is not a function!";
           }
         }
       }
@@ -3993,7 +3993,7 @@ fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: [ast::arg],
     let tcx = bcx.tcx();
     let arg_n: uint = 0u, bcx = bcx;
     let epic_fail = fn@() -> ! {
-        tcx.sess.bug("Someone forgot\
+        tcx.sess.bug("someone forgot\
                 to document an invariant in copy_args_to_allocas!");
     };
     for arg in arg_tys {
@@ -4306,7 +4306,7 @@ fn trans_const(cx: crate_ctxt, e: @ast::expr, id: ast::node_id) {
         llvm::LLVMSetInitializer(g, v);
         llvm::LLVMSetGlobalConstant(g, True);
       }
-      _ { cx.sess.span_fatal(e.span, "Unbound const in trans_const"); }
+      _ { cx.sess.span_bug(e.span, "unbound const in trans_const"); }
     }
 }
 
@@ -4319,7 +4319,7 @@ fn trans_item(ccx: crate_ctxt, item: ast::item) {
         let llfndecl = alt ccx.item_ids.find(item.id) {
           some(llfndecl) { llfndecl }
           _ {
-            ccx.sess.span_fatal(item.span,
+            ccx.sess.span_bug(item.span,
                                 "unbound function item in trans_item");
           }
         };

trunk/src/rustc/middle/trans/closure.rs

@@ -325,7 +325,7 @@ fn store_environment(
             bcx = base::copy_val(bcx, INIT, bound_data, val, ty);
           }
           env_copy(_, _, temporary) {
-            fail "Cannot capture temporary upvar";
+            fail "cannot capture temporary upvar";
           }
           env_move(val, ty, kind) {
             let src = {bcx:bcx, val:val, kind:kind};
@@ -339,7 +339,7 @@ fn store_environment(
             Store(bcx, addr, bound_data);
           }
           env_ref(_, _, temporary) {
-            fail "Cannot capture temporary upvar";
+            fail "cannot capture temporary upvar";
           }
         }
     }

trunk/src/rustc/middle/trans/impl.rs

@@ -55,7 +55,7 @@ fn trans_impl(ccx: crate_ctxt, path: path, name: ast::ident,
                      m_bounds, none, m.id, none);
           }
           _ {
-            ccx.sess.bug("Unbound id in trans_impl");
+            ccx.sess.bug("unbound id in trans_impl");
           }
         }
     }
@@ -347,7 +347,7 @@ fn trans_impl_vtable(ccx: crate_ctxt, pt: path,
                                extra_tps, target)
           }
           _ {
-            ccx.sess.span_bug(it.span, "No matching method \
+            ccx.sess.span_bug(it.span, "no matching method \
                in trans_impl_vtable");
           }
         }
@@ -459,7 +459,7 @@ fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
         @{def: did, params: []}
       }
       _ {
-        tcx.sess.bug("Unexpected dict_param in dict_id");
+        tcx.sess.bug("unexpected dict_param in dict_id");
       }
     }
 }
@@ -523,7 +523,7 @@ fn get_dict_ptrs(bcx: block, origin: typeck::dict_origin)
         {bcx: bcx, ptrs: [get_vtable(ccx, did)]}
       }
       _ {
-        bcx.tcx().sess.bug("Unexpected dict_param in get_dict_ptrs");
+        bcx.tcx().sess.bug("unexpected dict_param in get_dict_ptrs");
       }
     }
 }

trunk/src/rustc/middle/tstate/auxiliary.rs

@@ -596,7 +596,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use {
       expr_lit(l) { ret @respan(e.span, carg_lit(l)); }
       _ {
         tcx.sess.span_fatal(e.span,
-                            "Arguments to constrained functions must be " +
+                            "arguments to constrained functions must be " +
                                 "literals or local variables");
       }
     }
@@ -619,16 +619,13 @@ fn expr_to_constr(tcx: ty::ctxt, e: @expr) -> sp_constr {
                              exprs_to_constr_args(tcx, args)));
           }
           _ {
-            tcx.sess.span_fatal(operator.span,
-                                "Internal error: " +
-                                    " ill-formed operator \
-                                            in predicate");
+            tcx.sess.span_bug(operator.span,
+                              "ill-formed operator in predicate");
           }
         }
       }
       _ {
-        tcx.sess.span_fatal(e.span,
-                            "Internal error: " + " ill-formed predicate");
+        tcx.sess.span_bug(e.span, "ill-formed predicate");
       }
     }
 }
@@ -656,7 +653,7 @@ fn substitute_arg(cx: ty::ctxt, actuals: [@expr], a: @constr_arg) ->
         if i < num_actuals {
             ret expr_to_constr_arg(cx, actuals[i]);
         } else {
-            cx.sess.span_fatal(a.span, "Constraint argument out of bounds");
+            cx.sess.span_fatal(a.span, "constraint argument out of bounds");
         }
       }
       carg_base { ret @respan(a.span, carg_base); }
@@ -1029,7 +1026,7 @@ fn args_to_constr_args(tcx: ty::ctxt, args: [arg],
                                          node: args[i].id})
                          } else {
                              tcx.sess.span_bug(a.span,
-                                               "Index out of bounds in \
+                                               "index out of bounds in \
                   constraint arg");
                          }
                        }

trunk/src/rustc/middle/tstate/ck.rs

@@ -51,12 +51,12 @@ fn check_states_expr(e: @expr, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) {
         let s = "";
         let diff = first_difference_string(fcx, prec, pres);
         s +=
-            "Unsatisfied precondition constraint (for example, " + diff +
+            "unsatisfied precondition constraint (for example, " + diff +
                 ") for expression:\n";
         s += syntax::print::pprust::expr_to_str(e);
-        s += "\nPrecondition:\n";
+        s += "\nprecondition:\n";
         s += tritv_to_str(fcx, prec);
-        s += "\nPrestate:\n";
+        s += "\nprestate:\n";
         s += tritv_to_str(fcx, pres);
         fcx.ccx.tcx.sess.span_fatal(e.span, s);
     }
@@ -81,12 +81,12 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) {
         let ss = "";
         let diff = first_difference_string(fcx, prec, pres);
         ss +=
-            "Unsatisfied precondition constraint (for example, " + diff +
+            "unsatisfied precondition constraint (for example, " + diff +
                 ") for statement:\n";
         ss += syntax::print::pprust::stmt_to_str(*s);
-        ss += "\nPrecondition:\n";
+        ss += "\nprecondition:\n";
         ss += tritv_to_str(fcx, prec);
-        ss += "\nPrestate: \n";
+        ss += "\nprestate: \n";
         ss += tritv_to_str(fcx, pres);
         fcx.ccx.tcx.sess.span_fatal(s.span, ss);
     }
@@ -115,7 +115,7 @@ fn check_states_against_conditions(fcx: fn_ctxt,
            fcx.ccx.tcx, id))) &&
        f_decl.cf == return_val {
         fcx.ccx.tcx.sess.span_err(f_body.span,
-                                  "In function " + fcx.name +
+                                  "in function " + fcx.name +
                                       ", not all control paths \
                                         return a value");
         fcx.ccx.tcx.sess.span_fatal(f_decl.output.span,
@@ -129,7 +129,7 @@ fn check_states_against_conditions(fcx: fn_ctxt,
 
         if !promises(fcx, post, fcx.enclosing.i_diverge) {
             fcx.ccx.tcx.sess.span_fatal(f_body.span,
-                                        "In non-returning function " +
+                                        "in non-returning function " +
                                         fcx.name +
                                         ", some control paths may \
                                          return to the caller");