squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

fix alignment

Browse source
This commit is contained in:
Jorge Aparicio 2016-03-22 17:58:45 -05:00
parent bd71d11a8f
commit 2628f3cc8f
34 changed files with 458 additions and 473 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/compiletest/compiletest.rs
View file

@ -312,10 +312,10 @@ fn collect_tests_from_dir(config: &Config,
} else if file_path.is_dir() {
let relative_file_path = relative_dir_path.join(file.file_name());
collect_tests_from_dir(config,
base,
&file_path,
&relative_file_path,
tests)?;
base,
&file_path,
relative_file_path,
tests)?;
}
}
Ok(())

2
src/librustc/middle/def_id.rs
View file

@ -56,7 +56,7 @@ pub struct DefId {
impl fmt::Debug for DefId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "DefId {{ krate: {:?}, node: {:?}",
self.krate, self.index)?;
self.krate, self.index)?;
// Unfortunately, there seems to be no way to attempt to print
// a path for a def-id, so I'll just make a best effort for now

18
src/librustc/middle/infer/combine.rs
View file

@ -71,9 +71,9 @@ pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>,
// Relate integral variables to other types
(&ty::TyInfer(ty::IntVar(a_id)), &ty::TyInfer(ty::IntVar(b_id))) => {
infcx.int_unification_table
.borrow_mut()
.unify_var_var(a_id, b_id)
.map_err(|e| int_unification_error(a_is_expected, e))?;
.borrow_mut()
.unify_var_var(a_id, b_id)
.map_err(|e| int_unification_error(a_is_expected, e))?;
Ok(a)
}
(&ty::TyInfer(ty::IntVar(v_id)), &ty::TyInt(v)) => {
@ -92,9 +92,9 @@ pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>,
// Relate floating-point variables to other types
(&ty::TyInfer(ty::FloatVar(a_id)), &ty::TyInfer(ty::FloatVar(b_id))) => {
infcx.float_unification_table
.borrow_mut()
.unify_var_var(a_id, b_id)
.map_err(|e| float_unification_error(relation.a_is_expected(), e))?;
.borrow_mut()
.unify_var_var(a_id, b_id)
.map_err(|e| float_unification_error(relation.a_is_expected(), e))?;
Ok(a)
}
(&ty::TyInfer(ty::FloatVar(v_id)), &ty::TyFloat(v)) => {
@ -123,8 +123,7 @@ fn unify_integral_variable<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
val: ty::IntVarValue)
-> RelateResult<'tcx, Ty<'tcx>>
{
infcx
.int_unification_table
infcx.int_unification_table
.borrow_mut()
.unify_var_value(vid, val)
.map_err(|e| int_unification_error(vid_is_expected, e))?;
@ -140,8 +139,7 @@ fn unify_float_variable<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
val: ast::FloatTy)
-> RelateResult<'tcx, Ty<'tcx>>
{
infcx
.float_unification_table
infcx.float_unification_table
.borrow_mut()
.unify_var_value(vid, val)
.map_err(|e| float_unification_error(vid_is_expected, e))?;

4
src/librustc/middle/infer/sub.rs
View file

@ -76,8 +76,8 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
}
(&ty::TyInfer(TyVar(a_id)), _) => {
self.fields
.switch_expected()
.instantiate(b, SupertypeOf, a_id)?;
.switch_expected()
.instantiate(b, SupertypeOf, a_id)?;
Ok(a)
}
(_, &ty::TyInfer(TyVar(b_id))) => {

16
src/librustc/middle/traits/select.rs
View file

@ -1038,15 +1038,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// For other types, we'll use the builtin rules.
self.assemble_builtin_bound_candidates(ty::BoundCopy,
obligation,
&mut candidates)?;
obligation,
&mut candidates)?;
}
Some(bound @ ty::BoundSized) => {
// Sized is never implementable by end-users, it is
// always automatically computed.
self.assemble_builtin_bound_candidates(bound,
obligation,
&mut candidates)?;
obligation,
&mut candidates)?;
}
None if self.tcx().lang_items.unsize_trait() ==
@ -2422,8 +2422,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
.map_bound(|(trait_ref, _)| trait_ref);
self.confirm_poly_trait_refs(obligation.cause.clone(),
obligation.predicate.to_poly_trait_ref(),
trait_ref)?;
obligation.predicate.to_poly_trait_ref(),
trait_ref)?;
Ok(self_ty)
}
@ -2450,8 +2450,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
obligations);
self.confirm_poly_trait_refs(obligation.cause.clone(),
obligation.predicate.to_poly_trait_ref(),
trait_ref)?;
obligation.predicate.to_poly_trait_ref(),
trait_ref)?;
Ok(VtableClosureData {
closure_def_id: closure_def_id,

14
src/librustc/middle/ty/relate.rs
View file

@ -167,9 +167,9 @@ pub fn relate_substs<'a,'tcx:'a,R>(relation: &mut R,
let b_regions = b.get_slice(space);
let r_variances = variances.map(|v| v.regions.get_slice(space));
let regions = relate_region_params(relation,
r_variances,
a_regions,
b_regions)?;
r_variances,
a_regions,
b_regions)?;
substs.mut_regions().replace(space, regions);
}
}
@ -261,8 +261,8 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::FnSig<'tcx> {
}
let inputs = relate_arg_vecs(relation,
&a.inputs,
&b.inputs)?;
&a.inputs,
&b.inputs)?;
let output = match (a.output, b.output) {
(ty::FnConverging(a_ty), ty::FnConverging(b_ty)) =>
@ -557,8 +557,8 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R,
{
if as_.len() == bs.len() {
let ts = as_.iter().zip(bs)
.map(|(a, b)| relation.relate(a, b))
.collect::<Result<_, _>>()?;
.map(|(a, b)| relation.relate(a, b))
.collect::<Result<_, _>>()?;
Ok(tcx.mk_tup(ts))
} else if !(as_.is_empty() || bs.is_empty()) {
Err(TypeError::TupleSize(

4
src/librustc/mir/repr.rs
View file

@ -809,8 +809,8 @@ impl<'tcx> Debug for Rvalue<'tcx> {
let variant_def = &adt_def.variants[variant];
ppaux::parameterized(fmt, substs, variant_def.did,
ppaux::Ns::Value, &[],
|tcx| {
ppaux::Ns::Value, &[],
|tcx| {
tcx.lookup_item_type(variant_def.did).generics
})?;

10
src/librustc/util/ppaux.rs
View file

@ -123,8 +123,8 @@ pub fn parameterized<GG>(f: &mut fmt::Formatter,
for projection in projections {
start_or_continue(f, "<", ", ")?;
write!(f, "{}={}",
projection.projection_ty.item_name,
projection.ty)?;
projection.projection_ty.item_name,
projection.ty)?;
}
return start_or_continue(f, "", ">");
}
@ -201,8 +201,8 @@ pub fn parameterized<GG>(f: &mut fmt::Formatter,
for projection in projections {
start_or_continue(f, "<", ", ")?;
write!(f, "{}={}",
projection.projection_ty.item_name,
projection.ty)?;
projection.projection_ty.item_name,
projection.ty)?;
}
start_or_continue(f, "", ">")?;
@ -865,7 +865,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> {
write!(f, "{} {{", bare_fn.sig.0)?;
parameterized(f, substs, def_id, Ns::Value, &[],
|tcx| tcx.lookup_item_type(def_id).generics)?;
|tcx| tcx.lookup_item_type(def_id).generics)?;
write!(f, "}}")
}
TyFnPtr(ref bare_fn) => {

2
src/librustc_back/target/mod.rs
View file

@ -468,7 +468,7 @@ impl Target {
let mut contents = Vec::new();
f.read_to_end(&mut contents).map_err(|e| e.to_string())?;
let obj = json::from_reader(&mut &contents[..])
.map_err(|e| e.to_string())?;
.map_err(|e| e.to_string())?;
Ok(Target::from_json(obj))
}

42
src/librustc_borrowck/borrowck/mir/graphviz.rs
View file

@ -124,15 +124,15 @@ impl<'c, 'b:'c, 'a:'b, 'tcx:'a> dot::Labeller<'c> for Graph<'c,'b,'a,'tcx> {
write!(w, "</td><td></td><td></td></tr>")?;
}
write!(w, "<tr><td></td><td {bg} {align}>{objs:?}",
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT,
objs = c)?;
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT,
objs = c)?;
seen_one = true;
}
if !seen_one {
write!(w, "<tr><td></td><td {bg} {align}>[]",
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT)?;
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT)?;
}
Ok(())
}
@ -155,18 +155,18 @@ impl<'c, 'b:'c, 'a:'b, 'tcx:'a> dot::Labeller<'c> for Graph<'c,'b,'a,'tcx> {
let kill = flow.interpret_set(flow.sets.kill_set_for(i));
chunked_present_left(w, &gen[..], chunk_size)?;
write!(w, " = GEN:</td><td {bg}><FONT {face}>{genbits:?}</FONT></td>\
<td></td></tr>",
bg = BG_FLOWCONTENT,
face = FACE_MONOSPACE,
genbits=bits_to_string( flow.sets.gen_set_for(i),
flow.sets.bytes_per_block()))?;
<td></td></tr>",
bg = BG_FLOWCONTENT,
face = FACE_MONOSPACE,
genbits=bits_to_string( flow.sets.gen_set_for(i),
flow.sets.bytes_per_block()))?;
write!(w, "<tr><td></td><td {bg} {align}>KILL:</td>\
<td {bg}><FONT {face}>{killbits:?}</FONT></td>",
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT,
face = FACE_MONOSPACE,
killbits=bits_to_string(flow.sets.kill_set_for(i),
flow.sets.bytes_per_block()))?;
<td {bg}><FONT {face}>{killbits:?}</FONT></td>",
bg = BG_FLOWCONTENT,
align = ALIGN_RIGHT,
face = FACE_MONOSPACE,
killbits=bits_to_string(flow.sets.kill_set_for(i),
flow.sets.bytes_per_block()))?;
// (chunked_present_right)
let mut seen_one = false;
@ -174,19 +174,19 @@ impl<'c, 'b:'c, 'a:'b, 'tcx:'a> dot::Labeller<'c> for Graph<'c,'b,'a,'tcx> {
if !seen_one {
// continuation of row; this is fourth <td>
write!(w, "<td {bg}>= {kill:?}</td></tr>",
bg = BG_FLOWCONTENT,
kill=k)?;
bg = BG_FLOWCONTENT,
kill=k)?;
} else {
// new row, with indent of three <td>'s
write!(w, "<tr><td></td><td></td><td></td><td {bg}>{kill:?}</td></tr>",
bg = BG_FLOWCONTENT,
kill=k)?;
bg = BG_FLOWCONTENT,
kill=k)?;
}
seen_one = true;
}
if !seen_one {
write!(w, "<td {bg}>= []</td></tr>",
bg = BG_FLOWCONTENT)?;
bg = BG_FLOWCONTENT)?;
}
Ok(())

32
src/librustc_driver/driver.rs
View file

@ -100,10 +100,10 @@ pub fn compile_input(sess: &Session,
let outputs = build_output_filenames(input, outdir, output, &krate.attrs, sess);
let id = link::find_crate_name(Some(sess), &krate.attrs, input);
let expanded_crate = phase_2_configure_and_expand(sess,
&cstore,
krate,
&id[..],
addl_plugins)?;
&cstore,
krate,
&id[..],
addl_plugins)?;
(outputs, expanded_crate, id)
};
@ -169,12 +169,12 @@ pub fn compile_input(sess: &Session,
};
phase_3_run_analysis_passes(sess,
&cstore,
hir_map,
&arenas,
&id,
control.make_glob_map,
|tcx, mir_map, analysis, result| {
&cstore,
hir_map,
&arenas,
&id,
control.make_glob_map,
|tcx, mir_map, analysis, result| {
{
// Eventually, we will want to track plugins.
let _ignore = tcx.dep_graph.in_ignore();
@ -683,8 +683,8 @@ pub fn phase_2_configure_and_expand(sess: &Session,
})?;
time(time_passes,
"const fn bodies and arguments",
|| const_fn::check_crate(sess, &krate))?;
"const fn bodies and arguments",
|| const_fn::check_crate(sess, &krate))?;
if sess.opts.debugging_opts.input_stats {
println!("Post-expansion node count: {}", count_nodes(&krate));
@ -781,10 +781,10 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
};
let named_region_map = time(time_passes,
"lifetime resolution",
|| middle::resolve_lifetime::krate(sess,
&hir_map,
&def_map.borrow()))?;
"lifetime resolution",
|| middle::resolve_lifetime::krate(sess,
&hir_map,
&def_map.borrow()))?;
time(time_passes,
"looking for entry point",

106
src/librustc_front/print/pprust.rs
View file

@ -288,13 +288,13 @@ pub fn fun_to_string(decl: &hir::FnDecl,
to_string(|s| {
s.head("")?;
s.print_fn(decl,
unsafety,
constness,
Abi::Rust,
Some(name),
generics,
opt_explicit_self,
hir::Inherited)?;
unsafety,
constness,
Abi::Rust,
Some(name),
generics,
opt_explicit_self,
hir::Inherited)?;
s.end()?; // Close the head box
s.end() // Close the outer box
})
@ -567,13 +567,13 @@ impl<'a> State<'a> {
hir::ForeignItemFn(ref decl, ref generics) => {
self.head("")?;
self.print_fn(decl,
hir::Unsafety::Normal,
hir::Constness::NotConst,
Abi::Rust,
Some(item.name),
generics,
None,
item.vis)?;
hir::Unsafety::Normal,
hir::Constness::NotConst,
Abi::Rust,
Some(item.name),
generics,
None,
item.vis)?;
self.end()?; // end head-ibox
word(&mut self.s, ";")?;
self.end() // end the outer fn box
@ -704,13 +704,13 @@ impl<'a> State<'a> {
hir::ItemFn(ref decl, unsafety, constness, abi, ref typarams, ref body) => {
self.head("")?;
self.print_fn(decl,
unsafety,
constness,
abi,
Some(item.name),
typarams,
None,
item.vis)?;
unsafety,
constness,
abi,
Some(item.name),
typarams,
None,
item.vis)?;
word(&mut self.s, " ")?;
self.print_block_with_attrs(&body, &item.attrs)?;
}
@ -984,9 +984,9 @@ impl<'a> State<'a> {
match ti.node {
hir::ConstTraitItem(ref ty, ref default) => {
self.print_associated_const(ti.name,
&ty,
default.as_ref().map(|expr| &**expr),
hir::Inherited)?;
&ty,
default.as_ref().map(|expr| &**expr),
hir::Inherited)?;
}
hir::MethodTraitItem(ref sig, ref body) => {
if body.is_some() {
@ -1002,8 +1002,8 @@ impl<'a> State<'a> {
}
hir::TypeTraitItem(ref bounds, ref default) => {
self.print_associated_type(ti.name,
Some(bounds),
default.as_ref().map(|ty| &**ty))?;
Some(bounds),
default.as_ref().map(|ty| &**ty))?;
}
}
self.ann.post(self, NodeSubItem(ti.id))
@ -1219,15 +1219,15 @@ impl<'a> State<'a> {
self.print_path(path, true, 0)?;
word(&mut self.s, "{")?;
self.commasep_cmnt(Consistent,
&fields[..],
|s, field| {
s.ibox(indent_unit)?;
s.print_name(field.name.node)?;
s.word_space(":")?;
s.print_expr(&field.expr)?;
s.end()
},
|f| f.span)?;
&fields[..],
|s, field| {
s.ibox(indent_unit)?;
s.print_name(field.name.node)?;
s.word_space(":")?;
s.print_expr(&field.expr)?;
s.end()
},
|f| f.span)?;
match *wth {
Some(ref expr) => {
self.ibox(indent_unit)?;
@ -1760,17 +1760,17 @@ impl<'a> State<'a> {
self.nbsp()?;
self.word_space("{")?;
self.commasep_cmnt(Consistent,
&fields[..],
|s, f| {
s.cbox(indent_unit)?;
if !f.node.is_shorthand {
s.print_name(f.node.name)?;
s.word_nbsp(":")?;
}
s.print_pat(&f.node.pat)?;
s.end()
},
|f| f.node.pat.span)?;
&fields[..],
|s, f| {
s.cbox(indent_unit)?;
if !f.node.is_shorthand {
s.print_name(f.node.name)?;
s.word_nbsp(":")?;
}
s.print_pat(&f.node.pat)?;
s.end()
},
|f| f.node.pat.span)?;
if etc {
if !fields.is_empty() {
self.word_space(",")?;
@ -2261,13 +2261,13 @@ impl<'a> State<'a> {
},
};
self.print_fn(decl,
unsafety,
hir::Constness::NotConst,
abi,
name,
&generics,
opt_explicit_self,
hir::Inherited)?;
unsafety,
hir::Constness::NotConst,
abi,
name,
&generics,
opt_explicit_self,
hir::Inherited)?;
self.end()
}

10
src/librustc_mir/graphviz.rs
View file

@ -65,9 +65,9 @@ pub fn write_node_label<W: Write, INIT, FINI>(block: BasicBlock,
// Basic block number at the top.
write!(w, r#"<tr><td {attrs} colspan="{colspan}">{blk}</td></tr>"#,
attrs=r#"bgcolor="gray" align="center""#,
colspan=num_cols,
blk=block.index())?;
attrs=r#"bgcolor="gray" align="center""#,
colspan=num_cols,
blk=block.index())?;
init(w)?;
@ -145,13 +145,13 @@ fn write_graph_label<W: Write>(tcx: &ty::TyCtxt, nid: NodeId, mir: &Mir, w: &mut
write!(w, "mut ")?;
}
write!(w, r#"{:?}: {}; // {}<br align="left"/>"#,
Lvalue::Var(i as u32), escape(&var.ty), var.name)?;
Lvalue::Var(i as u32), escape(&var.ty), var.name)?;
}
// Compiler-introduced temporary types.
for (i, temp) in mir.temp_decls.iter().enumerate() {
write!(w, r#"let mut {:?}: {};<br align="left"/>"#,
Lvalue::Temp(i as u32), escape(&temp.ty))?;
Lvalue::Temp(i as u32), escape(&temp.ty))?;
}
writeln!(w, ">;")

4
src/librustc_trans/back/archive.rs
View file

@ -255,7 +255,7 @@ impl<'a> ArchiveBuilder<'a> {
// permission bits.
if let Some(ref s) = self.config.src {
io::copy(&mut File::open(s)?,
&mut File::create(&self.config.dst)?)?;
&mut File::create(&self.config.dst)?)?;
}
if removals.len() > 0 {
@ -272,7 +272,7 @@ impl<'a> ArchiveBuilder<'a> {
}
Addition::Archive { archive, archive_name, mut skip } => {
self.add_archive_members(&mut members, archive,
&archive_name, &mut *skip)?;
&archive_name, &mut *skip)?;
}
}
}

2
src/librustc_trans/trans/consts.rs
View file

@ -976,7 +976,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
let method_call = ty::MethodCall::expr(e.id);
let method = cx.tcx().tables.borrow().method_map[&method_call];
const_fn_call(cx, method.def_id, method.substs.clone(),
&arg_vals, param_substs, trueconst)?
&arg_vals, param_substs, trueconst)?
},
hir::ExprType(ref e, _) => const_expr(cx, &e, param_substs, fn_args, trueconst)?.0,
hir::ExprBlock(ref block) => {

8
src/librustc_typeck/astconv.rs
View file

@ -954,10 +954,10 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
}
let candidate = one_bound_for_assoc_type(tcx,
candidates,
&trait_ref.to_string(),
&binding.item_name.as_str(),
binding.span)?;
candidates,
&trait_ref.to_string(),
&binding.item_name.as_str(),
binding.span)?;
Ok(ty::Binder(ty::ProjectionPredicate { // <-------------------------+
projection_ty: ty::ProjectionTy { // |

11
src/librustc_typeck/check/dropck.rs
View file

@ -47,10 +47,10 @@ pub fn check_drop_impl(tcx: &TyCtxt, drop_impl_did: DefId) -> Result<(), ()> {
ty::TyEnum(adt_def, self_to_impl_substs) |
ty::TyStruct(adt_def, self_to_impl_substs) => {
ensure_drop_params_and_item_params_correspond(tcx,
drop_impl_did,
dtor_generics,
&dtor_self_type,
adt_def.did)?;
drop_impl_did,
dtor_generics,
&dtor_self_type,
adt_def.did)?;
ensure_drop_predicates_are_implied_by_item_defn(tcx,
drop_impl_did,
@ -469,8 +469,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'b, 'tcx>(
ty::TyTuple(ref tys) |
ty::TyClosure(_, box ty::ClosureSubsts { upvar_tys: ref tys, .. }) => {
for ty in tys {
iterate_over_potentially_unsafe_regions_in_type(
cx, context, ty, depth+1)?
iterate_over_potentially_unsafe_regions_in_type(cx, context, ty, depth+1)?
}
Ok(())
}

12
src/librustc_typeck/lib.rs
View file

@ -354,17 +354,13 @@ pub fn check_crate(tcx: &TyCtxt, trait_map: ty::TraitMap) -> CompileResult {
coherence::check_coherence(&ccx));
})?;
time(time_passes, "wf checking", ||
check::check_wf_new(&ccx))?;
time(time_passes, "wf checking", || check::check_wf_new(&ccx))?;
time(time_passes, "item-types checking", ||
check::check_item_types(&ccx))?;
time(time_passes, "item-types checking", || check::check_item_types(&ccx))?;
time(time_passes, "item-bodies checking", ||
check::check_item_bodies(&ccx))?;
time(time_passes, "item-bodies checking", || check::check_item_bodies(&ccx))?;
time(time_passes, "drop-impl checking", ||
check::check_drop_impls(&ccx))?;
time(time_passes, "drop-impl checking", || check::check_drop_impls(&ccx))?;
check_for_entry_fn(&ccx);

27
src/librustdoc/html/format.rs
View file

@ -344,9 +344,9 @@ fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,
root.push_str(&seg.name);
root.push_str("/");
write!(w, "<a class='mod'
href='{}index.html'>{}</a>::",
root,
seg.name)?;
href='{}index.html'>{}</a>::",
root,
seg.name)?;
}
}
}
@ -361,7 +361,7 @@ fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,
match href(did) {
Some((url, shortty, fqp)) => {
write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
shortty, url, fqp.join("::"), last.name)?;
shortty, url, fqp.join("::"), last.name)?;
}
_ => write!(w, "{}", last.name)?,
}
@ -379,8 +379,8 @@ fn primitive_link(f: &mut fmt::Formatter,
let len = CURRENT_LOCATION_KEY.with(|s| s.borrow().len());
let len = if len == 0 {0} else {len - 1};
write!(f, "<a class='primitive' href='{}primitive.{}.html'>",
repeat("../").take(len).collect::<String>(),
prim.to_url_str())?;
repeat("../").take(len).collect::<String>(),
prim.to_url_str())?;
needs_termination = true;
}
Some(&cnum) => {
@ -399,9 +399,9 @@ fn primitive_link(f: &mut fmt::Formatter,
match loc {
Some(root) => {
write!(f, "<a class='primitive' href='{}{}/primitive.{}.html'>",
root,
path.0.first().unwrap(),
prim.to_url_str())?;
root,
path.0.first().unwrap(),
prim.to_url_str())?;
needs_termination = true;
}
None => {}
@ -490,7 +490,7 @@ impl fmt::Display for clean::Type {
}
_ => {
primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
&format!("*{}", RawMutableSpace(m)))?;
&format!("*{}", RawMutableSpace(m)))?;
write!(f, "{}", t)
}
}
@ -508,8 +508,7 @@ impl fmt::Display for clean::Type {
primitive_link(f, clean::Slice,
&format!("&amp;{}{}[{}]", lt, m, **bt)),
_ => {
primitive_link(f, clean::Slice,
&format!("&amp;{}{}[", lt, m))?;
primitive_link(f, clean::Slice, &format!("&amp;{}{}[", lt, m))?;
write!(f, "{}", **bt)?;
primitive_link(f, clean::Slice, "]")
}
@ -567,8 +566,8 @@ impl fmt::Display for clean::Impl {
write!(f, "impl{} ", self.generics)?;
if let Some(ref ty) = self.trait_ {
write!(f, "{}{} for ",
if self.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
*ty)?;
if self.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
*ty)?;
}
write!(f, "{}{}", self.for_, WhereClause(&self.generics))?;
Ok(())

5
src/librustdoc/html/highlight.rs
View file

@ -71,7 +71,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader,
},
token::Comment => {
write!(out, "<span class='comment'>{}</span>",
Escape(&snip(next.sp)))?;
Escape(&snip(next.sp)))?;
continue
},
token::Shebang(s) => {
@ -180,8 +180,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader,
if klass == "" {
write!(out, "{}", Escape(&snip))?;
} else {
write!(out, "<span class='{}'>{}</span>", klass,
Escape(&snip))?;
write!(out, "<span class='{}'>{}</span>", klass, Escape(&snip))?;
}
}

273
src/librustdoc/html/render.rs
View file

@ -630,45 +630,45 @@ fn write_shared(cx: &Context,
// Add all the static files. These may already exist, but we just
// overwrite them anyway to make sure that they're fresh and up-to-date.
write(cx.dst.join("jquery.js"),
include_bytes!("static/jquery-2.1.4.min.js"))?;
include_bytes!("static/jquery-2.1.4.min.js"))?;
write(cx.dst.join("main.js"),
include_bytes!("static/main.js"))?;
include_bytes!("static/main.js"))?;
write(cx.dst.join("playpen.js"),
include_bytes!("static/playpen.js"))?;
include_bytes!("static/playpen.js"))?;
write(cx.dst.join("rustdoc.css"),
include_bytes!("static/rustdoc.css"))?;
include_bytes!("static/rustdoc.css"))?;
write(cx.dst.join("main.css"),
include_bytes!("static/styles/main.css"))?;
include_bytes!("static/styles/main.css"))?;
write(cx.dst.join("normalize.css"),
include_bytes!("static/normalize.css"))?;
include_bytes!("static/normalize.css"))?;
write(cx.dst.join("FiraSans-Regular.woff"),
include_bytes!("static/FiraSans-Regular.woff"))?;
include_bytes!("static/FiraSans-Regular.woff"))?;
write(cx.dst.join("FiraSans-Medium.woff"),
include_bytes!("static/FiraSans-Medium.woff"))?;
include_bytes!("static/FiraSans-Medium.woff"))?;
write(cx.dst.join("FiraSans-LICENSE.txt"),
include_bytes!("static/FiraSans-LICENSE.txt"))?;
include_bytes!("static/FiraSans-LICENSE.txt"))?;
write(cx.dst.join("Heuristica-Italic.woff"),
include_bytes!("static/Heuristica-Italic.woff"))?;
include_bytes!("static/Heuristica-Italic.woff"))?;
write(cx.dst.join("Heuristica-LICENSE.txt"),
include_bytes!("static/Heuristica-LICENSE.txt"))?;
include_bytes!("static/Heuristica-LICENSE.txt"))?;
write(cx.dst.join("SourceSerifPro-Regular.woff"),
include_bytes!("static/SourceSerifPro-Regular.woff"))?;
include_bytes!("static/SourceSerifPro-Regular.woff"))?;
write(cx.dst.join("SourceSerifPro-Bold.woff"),
include_bytes!("static/SourceSerifPro-Bold.woff"))?;
include_bytes!("static/SourceSerifPro-Bold.woff"))?;
write(cx.dst.join("SourceSerifPro-LICENSE.txt"),
include_bytes!("static/SourceSerifPro-LICENSE.txt"))?;
include_bytes!("static/SourceSerifPro-LICENSE.txt"))?;
write(cx.dst.join("SourceCodePro-Regular.woff"),
include_bytes!("static/SourceCodePro-Regular.woff"))?;
include_bytes!("static/SourceCodePro-Regular.woff"))?;
write(cx.dst.join("SourceCodePro-Semibold.woff"),
include_bytes!("static/SourceCodePro-Semibold.woff"))?;
include_bytes!("static/SourceCodePro-Semibold.woff"))?;
write(cx.dst.join("SourceCodePro-LICENSE.txt"),
include_bytes!("static/SourceCodePro-LICENSE.txt"))?;
include_bytes!("static/SourceCodePro-LICENSE.txt"))?;
write(cx.dst.join("LICENSE-MIT.txt"),
include_bytes!("static/LICENSE-MIT.txt"))?;
include_bytes!("static/LICENSE-MIT.txt"))?;
write(cx.dst.join("LICENSE-APACHE.txt"),
include_bytes!("static/LICENSE-APACHE.txt"))?;
include_bytes!("static/LICENSE-APACHE.txt"))?;
write(cx.dst.join("COPYRIGHT.txt"),
include_bytes!("static/COPYRIGHT.txt"))?;
include_bytes!("static/COPYRIGHT.txt"))?;
fn collect(path: &Path, krate: &str,
key: &str) -> io::Result<Vec<String>> {
@ -925,7 +925,7 @@ impl<'a> SourceCollector<'a> {
keywords: BASIC_KEYWORDS,
};
layout::render(&mut w, &self.cx.layout,
&page, &(""), &Source(contents))?;
&page, &(""), &Source(contents))?;
w.flush()?;
self.cx.local_sources.insert(p, href);
Ok(())
@ -1290,8 +1290,8 @@ impl Context {
let mut writer = BufWriter::new(w);
if !cx.render_redirect_pages {
layout::render(&mut writer, &cx.layout, &page,
&Sidebar{ cx: cx, item: it },
&Item{ cx: cx, item: it })?;
&Sidebar{ cx: cx, item: it },
&Item{ cx: cx, item: it })?;
} else {
let mut url = repeat("../").take(cx.current.len())
.collect::<String>();
@ -1515,22 +1515,22 @@ impl<'a> fmt::Display for Item<'a> {
let amt = if self.ismodule() { cur.len() - 1 } else { cur.len() };
for (i, component) in cur.iter().enumerate().take(amt) {
write!(fmt, "<a href='{}index.html'>{}</a>::<wbr>",
repeat("../").take(cur.len() - i - 1)
.collect::<String>(),
component)?;
repeat("../").take(cur.len() - i - 1)
.collect::<String>(),
component)?;
}
}
write!(fmt, "<a class='{}' href=''>{}</a>",
shortty(self.item), self.item.name.as_ref().unwrap())?;
shortty(self.item), self.item.name.as_ref().unwrap())?;
write!(fmt, "</span>")?; // in-band
write!(fmt, "<span class='out-of-band'>")?;
write!(fmt,
r##"<span id='render-detail'>
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span>"##)?;
r##"<span id='render-detail'>
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>&#x2212;</span>]
</a>
</span>"##)?;
// Write `src` tag
//
@ -1541,8 +1541,8 @@ impl<'a> fmt::Display for Item<'a> {
if self.cx.include_sources && !is_primitive {
if let Some(l) = self.href() {
write!(fmt, "<a id='src-{}' class='srclink' \
href='{}' title='{}'>[src]</a>",
self.item.def_id.index.as_usize(), l, "goto source code")?;
href='{}' title='{}'>[src]</a>",
self.item.def_id.index.as_usize(), l, "goto source code")?;
}
}
@ -1698,8 +1698,8 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
ItemType::AssociatedConst => ("associated-consts", "Associated Constants"),
};
write!(w, "<h2 id='{id}' class='section-header'>\
<a href=\"#{id}\">{name}</a></h2>\n<table>",
id = derive_id(short.to_owned()), name = name)?;
<a href=\"#{id}\">{name}</a></h2>\n<table>",
id = derive_id(short.to_owned()), name = name)?;
}
match myitem.inner {
@ -1707,13 +1707,13 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
match *src {
Some(ref src) => {
write!(w, "<tr><td><code>{}extern crate {} as {};",
VisSpace(myitem.visibility),
src,
name)?
VisSpace(myitem.visibility),
src,
name)?
}
None => {
write!(w, "<tr><td><code>{}extern crate {};",
VisSpace(myitem.visibility), name)?
VisSpace(myitem.visibility), name)?
}
}
write!(w, "</code></td></tr>")?;
@ -1721,7 +1721,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
clean::ImportItem(ref import) => {
write!(w, "<tr><td><code>{}{}</code></td></tr>",
VisSpace(myitem.visibility), *import)?;
VisSpace(myitem.visibility), *import)?;
}
_ => {
@ -1733,21 +1733,20 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
};
let doc_value = myitem.doc_value().unwrap_or("");
write!(w, "
<tr class='{stab} module-item'>
<td><a class='{class}' href='{href}'
title='{title}'>{name}</a></td>
<td class='docblock short'>
{stab_docs} {docs}
</td>
</tr>
",
name = *myitem.name.as_ref().unwrap(),
stab_docs = stab_docs,
docs = shorter(Some(&Markdown(doc_value).to_string())),
class = shortty(myitem),
stab = myitem.stability_class(),
href = item_path(myitem),
title = full_path(cx, myitem))?;
<tr class='{stab} module-item'>
<td><a class='{class}' href='{href}'
title='{title}'>{name}</a></td>
<td class='docblock short'>
{stab_docs} {docs}
</td>
</tr>",
name = *myitem.name.as_ref().unwrap(),
stab_docs = stab_docs,
docs = shorter(Some(&Markdown(doc_value).to_string())),
class = shortty(myitem),
stab = myitem.stability_class(),
href = item_path(myitem),
title = full_path(cx, myitem))?;
}
}
}
@ -1824,7 +1823,7 @@ impl<'a> fmt::Display for Initializer<'a> {
fn item_constant(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
c: &clean::Constant) -> fmt::Result {
write!(w, "<pre class='rust const'>{vis}const \
{name}: {typ}{init}</pre>",
{name}: {typ}{init}</pre>",
vis = VisSpace(it.visibility),
name = it.name.as_ref().unwrap(),
typ = c.type_,
@ -1835,7 +1834,7 @@ fn item_constant(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
fn item_static(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
s: &clean::Static) -> fmt::Result {
write!(w, "<pre class='rust static'>{vis}static {mutability}\
{name}: {typ}{init}</pre>",
{name}: {typ}{init}</pre>",
vis = VisSpace(it.visibility),
mutability = MutableSpace(s.mutability),
name = it.name.as_ref().unwrap(),
@ -1851,7 +1850,7 @@ fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
_ => hir::Constness::NotConst
};
write!(w, "<pre class='rust fn'>{vis}{constness}{unsafety}{abi}fn \
{name}{generics}{decl}{where_clause}</pre>",
{name}{generics}{decl}{where_clause}</pre>",
vis = VisSpace(it.visibility),
constness = ConstnessSpace(vis_constness),
unsafety = UnsafetySpace(f.unsafety),
@ -1880,12 +1879,12 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
// Output the trait definition
write!(w, "<pre class='rust trait'>{}{}trait {}{}{}{} ",
VisSpace(it.visibility),
UnsafetySpace(t.unsafety),
it.name.as_ref().unwrap(),
t.generics,
bounds,
WhereClause(&t.generics))?;
VisSpace(it.visibility),
UnsafetySpace(t.unsafety),
it.name.as_ref().unwrap(),
t.generics,
bounds,
WhereClause(&t.generics))?;
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
@ -1937,8 +1936,8 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
let name = m.name.as_ref().unwrap();
let id = derive_id(format!("{}.{}", shortty(m), name));
write!(w, "<h3 id='{id}' class='method stab {stab}'><code>",
id = id,
stab = m.stability_class())?;
id = id,
stab = m.stability_class())?;
render_assoc_item(w, m, AssocItemLink::Anchor)?;
write!(w, "</code>")?;
render_stability_since(w, m, t)?;
@ -2009,17 +2008,17 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
}
write!(w, "</ul>")?;
write!(w, r#"<script type="text/javascript" async
src="{root_path}/implementors/{path}/{ty}.{name}.js">
</script>"#,
root_path = vec![".."; cx.current.len()].join("/"),
path = if it.def_id.is_local() {
cx.current.join("/")
} else {
let path = &cache.external_paths[&it.def_id];
path[..path.len() - 1].join("/")
},
ty = shortty(it).to_static_str(),
name = *it.name.as_ref().unwrap())?;
src="{root_path}/implementors/{path}/{ty}.{name}.js">
</script>"#,
root_path = vec![".."; cx.current.len()].join("/"),
path = if it.def_id.is_local() {
cx.current.join("/")
} else {
let path = &cache.external_paths[&it.def_id];
path[..path.len() - 1].join("/")
},
ty = shortty(it).to_static_str(),
name = *it.name.as_ref().unwrap())?;
Ok(())
}
@ -2054,7 +2053,7 @@ fn render_stability_since_raw<'a>(w: &mut fmt::Formatter,
if let Some(v) = ver {
if containing_ver != ver && v.len() > 0 {
write!(w, "<span class=\"since\">{}</span>",
v)?
v)?
}
}
Ok(())
@ -2131,12 +2130,12 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
write!(w, "<pre class='rust struct'>")?;
render_attributes(w, it)?;
render_struct(w,
it,
Some(&s.generics),
s.struct_type,
&s.fields,
"",
true)?;
it,
Some(&s.generics),
s.struct_type,
&s.fields,
"",
true)?;
write!(w, "</pre>")?;
render_stability_since_raw(w, it.stable_since(), None)?;
@ -2153,10 +2152,10 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
write!(w, "<h2 class='fields'>Fields</h2>\n<table>")?;
for field in fields {
write!(w, "<tr class='stab {stab}'>
<td id='structfield.{name}'>\
<code>{name}</code></td><td>",
stab = field.stability_class(),
name = field.name.as_ref().unwrap())?;
<td id='structfield.{name}'>\
<code>{name}</code></td><td>",
stab = field.stability_class(),
name = field.name.as_ref().unwrap())?;
document(w, cx, field)?;
write!(w, "</td></tr>")?;
}
@ -2171,10 +2170,10 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
write!(w, "<pre class='rust enum'>")?;
render_attributes(w, it)?;
write!(w, "{}enum {}{}{}",
VisSpace(it.visibility),
it.name.as_ref().unwrap(),
e.generics,
WhereClause(&e.generics))?;
VisSpace(it.visibility),
it.name.as_ref().unwrap(),
e.generics,
WhereClause(&e.generics))?;
if e.variants.is_empty() && !e.variants_stripped {
write!(w, " {{}}")?;
} else {
@ -2198,12 +2197,12 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
}
clean::StructVariant(ref s) => {
render_struct(w,
v,
None,
s.struct_type,
&s.fields,
" ",
false)?;
v,
None,
s.struct_type,
&s.fields,
" ",
false)?;
}
}
}
@ -2225,7 +2224,7 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
write!(w, "<h2 class='variants'>Variants</h2>\n<table class='variants_table'>")?;
for variant in &e.variants {
write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>",
name = variant.name.as_ref().unwrap())?;
name = variant.name.as_ref().unwrap())?;
document(w, cx, variant)?;
use clean::{Variant, StructVariant};
@ -2237,13 +2236,13 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
}
});
write!(w, "<h3 class='fields'>Fields</h3>\n
<table>")?;
<table>")?;
for field in fields {
write!(w, "<tr><td \
id='variant.{v}.field.{f}'>\
<code>{f}</code></td><td>",
v = variant.name.as_ref().unwrap(),
f = field.name.as_ref().unwrap())?;
id='variant.{v}.field.{f}'>\
<code>{f}</code></td><td>",
v = variant.name.as_ref().unwrap(),
f = field.name.as_ref().unwrap())?;
document(w, cx, field)?;
write!(w, "</td></tr>")?;
}
@ -2281,9 +2280,9 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
tab: &str,
structhead: bool) -> fmt::Result {
write!(w, "{}{}{}",
VisSpace(it.visibility),
if structhead {"struct "} else {""},
it.name.as_ref().unwrap())?;
VisSpace(it.visibility),
if structhead {"struct "} else {""},
it.name.as_ref().unwrap())?;
if let Some(g) = g {
write!(w, "{}{}", *g, WhereClause(g))?
}
@ -2298,10 +2297,10 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
}
clean::StructFieldItem(clean::TypedStructField(ref ty)) => {
write!(w, " {}{}: {},\n{}",
VisSpace(field.visibility),
field.name.as_ref().unwrap(),
*ty,
tab)?;
VisSpace(field.visibility),
field.name.as_ref().unwrap(),
*ty,
tab)?;
}
_ => unreachable!(),
};
@ -2369,13 +2368,13 @@ fn render_assoc_items(w: &mut fmt::Formatter,
}
AssocItemRender::DerefFor { trait_, type_ } => {
write!(w, "<h2 id='deref-methods'>Methods from \
{}&lt;Target={}&gt;</h2>", trait_, type_)?;
{}&lt;Target={}&gt;</h2>", trait_, type_)?;
false
}
};
for i in &non_trait {
render_impl(w, cx, i, AssocItemLink::Anchor, render_header,
containing_item.stable_since())?;
containing_item.stable_since())?;
}
}
if let AssocItemRender::DerefFor { .. } = what {
@ -2394,23 +2393,23 @@ fn render_assoc_items(w: &mut fmt::Formatter,
render_deref_methods(w, cx, impl_, containing_item)?;
}
write!(w, "<h2 id='implementations'>Trait \
Implementations</h2>")?;
Implementations</h2>")?;
let (derived, manual): (Vec<_>, Vec<&Impl>) = traits.iter().partition(|i| {
i.impl_.derived
});
for i in &manual {
let did = i.trait_did().unwrap();
render_impl(w, cx, i, AssocItemLink::GotoSource(did), true,
containing_item.stable_since())?;
containing_item.stable_since())?;
}
if !derived.is_empty() {
write!(w, "<h3 id='derived_implementations'>\
Derived Implementations \
</h3>")?;
Derived Implementations \
</h3>")?;
for i in &derived {
let did = i.trait_did().unwrap();
render_impl(w, cx, i, AssocItemLink::GotoSource(did), true,
containing_item.stable_since())?;
containing_item.stable_since())?;
}
}
}
@ -2533,7 +2532,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
}
doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static,
outer_version)?;
outer_version)?;
}
Ok(())
}
@ -2554,10 +2553,10 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
fn item_typedef(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Typedef) -> fmt::Result {
write!(w, "<pre class='rust typedef'>type {}{}{where_clause} = {type_};</pre>",
it.name.as_ref().unwrap(),
t.generics,
where_clause = WhereClause(&t.generics),
type_ = t.type_)?;
it.name.as_ref().unwrap(),
t.generics,
where_clause = WhereClause(&t.generics),
type_ = t.type_)?;
document(w, cx, it)
}
@ -2582,28 +2581,28 @@ impl<'a> fmt::Display for Sidebar<'a> {
write!(fmt, "::<wbr>")?;
}
write!(fmt, "<a href='{}index.html'>{}</a>",
&cx.root_path[..(cx.current.len() - i - 1) * 3],
*name)?;
&cx.root_path[..(cx.current.len() - i - 1) * 3],
*name)?;
}
write!(fmt, "</p>")?;
// sidebar refers to the enclosing module, not this module
let relpath = if it.is_mod() { "../" } else { "" };
write!(fmt,
"<script>window.sidebarCurrent = {{\
name: '{name}', \
ty: '{ty}', \
relpath: '{path}'\
}};</script>",
name = it.name.as_ref().map(|x| &x[..]).unwrap_or(""),
ty = shortty(it).to_static_str(),
path = relpath)?;
"<script>window.sidebarCurrent = {{\
name: '{name}', \
ty: '{ty}', \
relpath: '{path}'\
}};</script>",
name = it.name.as_ref().map(|x| &x[..]).unwrap_or(""),
ty = shortty(it).to_static_str(),
path = relpath)?;
if parentlen == 0 {
// there is no sidebar-items.js beyond the crate root path
// FIXME maybe dynamic crate loading can be merged here
} else {
write!(fmt, "<script defer src=\"{path}sidebar-items.js\"></script>",
path = relpath)?;
path = relpath)?;
}
Ok(())
@ -2633,8 +2632,8 @@ impl<'a> fmt::Display for Source<'a> {
fn item_macro(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Macro) -> fmt::Result {
w.write_str(&highlight::highlight(&t.source,
Some("macro"),
None))?;
Some("macro"),
None))?;
render_stability_since_raw(w, it.stable_since(), None)?;
document(w, cx, it)
}

8
src/librustdoc/html/toc.rs
View file

@ -188,10 +188,10 @@ impl fmt::Display for Toc {
// recursively format this table of contents (the
// `{children}` is the key).
write!(fmt,
"\n<li><a href=\"#{id}\">{num} {name}</a>{children}</li>",
id = entry.id,
num = entry.sec_number, name = entry.name,
children = entry.children)?
"\n<li><a href=\"#{id}\">{num} {name}</a>{children}</li>",
id = entry.id,
num = entry.sec_number, name = entry.name,
children = entry.children)?
}
write!(fmt, "</ul>")
}

12
src/libstd/sys/common/net.rs
View file

@ -49,7 +49,7 @@ pub fn setsockopt<T>(sock: &Socket, opt: c_int, val: c_int,
unsafe {
let payload = &payload as *const T as *const c_void;
cvt(c::setsockopt(*sock.as_inner(), opt, val, payload,
mem::size_of::<T>() as c::socklen_t))?;
mem::size_of::<T>() as c::socklen_t))?;
Ok(())
}
}
@ -60,8 +60,8 @@ pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int,
let mut slot: T = mem::zeroed();
let mut len = mem::size_of::<T>() as c::socklen_t;
cvt(c::getsockopt(*sock.as_inner(), opt, val,
&mut slot as *mut _ as *mut _,
&mut len))?;
&mut slot as *mut _ as *mut _,
&mut len))?;
assert_eq!(len as usize, mem::size_of::<T>());
Ok(slot)
}
@ -147,7 +147,7 @@ pub fn lookup_host(host: &str) -> io::Result<LookupHost> {
let mut res = ptr::null_mut();
unsafe {
cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), ptr::null(),
&mut res))?;
&mut res))?;
Ok(LookupHost { original: res, cur: res })
}
}
@ -308,7 +308,7 @@ impl TcpListener {
// the OS to clean up the previous one.
if !cfg!(windows) {
setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR,
1 as c_int)?;
1 as c_int)?;
}
// Bind our new socket
@ -334,7 +334,7 @@ impl TcpListener {
let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() };
let mut len = mem::size_of_val(&storage) as c::socklen_t;
let sock = self.inner.accept(&mut storage as *mut _ as *mut _,
&mut len)?;
&mut len)?;
let addr = sockaddr_to_addr(&storage, len as usize)?;
Ok((TcpStream { inner: sock, }, addr))
}

10
src/libstd/sys/unix/ext/net.rs
View file

@ -642,11 +642,11 @@ impl UnixDatagram {
let (addr, len) = sockaddr_un(path)?;
let count = cvt(libc::sendto(*d.0.as_inner(),
buf.as_ptr() as *const _,
buf.len(),
0,
&addr as *const _ as *const _,
len))?;
buf.as_ptr() as *const _,
buf.len(),
0,
&addr as *const _ as *const _,
len))?;
Ok(count as usize)
}
}

12
src/libstd/sys/unix/os.rs
View file

@ -181,15 +181,15 @@ pub fn current_exe() -> io::Result<PathBuf> {
-1 as c_int];
let mut sz: libc::size_t = 0;
cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
ptr::null_mut(), &mut sz, ptr::null_mut(),
0 as libc::size_t))?;
ptr::null_mut(), &mut sz, ptr::null_mut(),
0 as libc::size_t))?;
if sz == 0 {
return Err(io::Error::last_os_error())
}
let mut v: Vec<u8> = Vec::with_capacity(sz as usize);
cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
v.as_mut_ptr() as *mut libc::c_void, &mut sz,
ptr::null_mut(), 0 as libc::size_t))?;
v.as_mut_ptr() as *mut libc::c_void, &mut sz,
ptr::null_mut(), 0 as libc::size_t))?;
if sz == 0 {
return Err(io::Error::last_os_error());
}
@ -218,10 +218,10 @@ pub fn current_exe() -> io::Result<PathBuf> {
let mib = mib.as_mut_ptr();
let mut argv_len = 0;
cvt(libc::sysctl(mib, 4, 0 as *mut _, &mut argv_len,
0 as *mut _, 0))?;
0 as *mut _, 0))?;
let mut argv = Vec::<*const libc::c_char>::with_capacity(argv_len as usize);
cvt(libc::sysctl(mib, 4, argv.as_mut_ptr() as *mut _,
&mut argv_len, 0 as *mut _, 0))?;
&mut argv_len, 0 as *mut _, 0))?;
argv.set_len(argv_len as usize);
if argv[0].is_null() {
return Err(io::Error::new(io::ErrorKind::Other,

2
src/libstd/sys/unix/process.rs
View file

@ -392,7 +392,7 @@ impl Command {
let mut set: libc::sigset_t = mem::uninitialized();
t!(cvt(libc::sigemptyset(&mut set)));
t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set,
ptr::null_mut())));
ptr::null_mut())));
let ret = libc::signal(libc::SIGPIPE, libc::SIG_DFL);
if ret == libc::SIG_ERR {
return io::Error::last_os_error()

2
src/libstd/sys/windows/fs.rs
View file

@ -290,7 +290,7 @@ impl File {
unsafe {
let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed();
cvt(c::GetFileInformationByHandle(self.handle.raw(),
&mut info))?;
&mut info))?;
let mut attr = FileAttr {
attributes: info.dwFileAttributes,
creation_time: info.ftCreationTime,

4
src/libstd/sys/windows/process.rs
View file

@ -188,9 +188,9 @@ impl Command {
let stderr = self.stderr.as_ref().unwrap_or(&default);
let stdin = stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin)?;
let stdout = stdout.to_handle(c::STD_OUTPUT_HANDLE,
&mut pipes.stdout)?;
&mut pipes.stdout)?;
let stderr = stderr.to_handle(c::STD_ERROR_HANDLE,
&mut pipes.stderr)?;
&mut pipes.stderr)?;
si.hStdInput = stdin.raw();
si.hStdOutput = stdout.raw();
si.hStdError = stderr.raw();

118
src/libsyntax/codemap.rs
View file

@ -530,51 +530,51 @@ impl Encodable for FileMap {
s.emit_struct_field("start_pos", 1, |s| self.start_pos.encode(s))?;
s.emit_struct_field("end_pos", 2, |s| self.end_pos.encode(s))?;
s.emit_struct_field("lines", 3, |s| {
let lines = self.lines.borrow();
// store the length
s.emit_u32(lines.len() as u32)?;
let lines = self.lines.borrow();
// store the length
s.emit_u32(lines.len() as u32)?;
if !lines.is_empty() {
// In order to preserve some space, we exploit the fact that
// the lines list is sorted and individual lines are
// probably not that long. Because of that we can store lines
// as a difference list, using as little space as possible
// for the differences.
let max_line_length = if lines.len() == 1 {
0
} else {
lines.windows(2)
.map(|w| w[1] - w[0])
.map(|bp| bp.to_usize())
.max()
.unwrap()
};
if !lines.is_empty() {
// In order to preserve some space, we exploit the fact that
// the lines list is sorted and individual lines are
// probably not that long. Because of that we can store lines
// as a difference list, using as little space as possible
// for the differences.
let max_line_length = if lines.len() == 1 {
0
} else {
lines.windows(2)
.map(|w| w[1] - w[0])
.map(|bp| bp.to_usize())
.max()
.unwrap()
};
let bytes_per_diff: u8 = match max_line_length {
0 ... 0xFF => 1,
0x100 ... 0xFFFF => 2,
_ => 4
};
let bytes_per_diff: u8 = match max_line_length {
0 ... 0xFF => 1,
0x100 ... 0xFFFF => 2,
_ => 4
};
// Encode the number of bytes used per diff.
bytes_per_diff.encode(s)?;
// Encode the number of bytes used per diff.
bytes_per_diff.encode(s)?;
// Encode the first element.
lines[0].encode(s)?;
// Encode the first element.
lines[0].encode(s)?;
let diff_iter = (&lines[..]).windows(2)
.map(|w| (w[1] - w[0]));
let diff_iter = (&lines[..]).windows(2)
.map(|w| (w[1] - w[0]));
match bytes_per_diff {
1 => for diff in diff_iter { (diff.0 as u8).encode(s)? },
2 => for diff in diff_iter { (diff.0 as u16).encode(s)? },
4 => for diff in diff_iter { diff.0.encode(s)? },
_ => unreachable!()
}
match bytes_per_diff {
1 => for diff in diff_iter { (diff.0 as u8).encode(s)? },
2 => for diff in diff_iter { (diff.0 as u16).encode(s)? },
4 => for diff in diff_iter { diff.0.encode(s)? },
_ => unreachable!()
}
}
Ok(())
})?;
Ok(())
})?;
s.emit_struct_field("multibyte_chars", 4, |s| {
(*self.multibyte_chars.borrow()).encode(s)
})
@ -590,33 +590,33 @@ impl Decodable for FileMap {
let start_pos: BytePos = d.read_struct_field("start_pos", 1, |d| Decodable::decode(d))?;
let end_pos: BytePos = d.read_struct_field("end_pos", 2, |d| Decodable::decode(d))?;
let lines: Vec<BytePos> = d.read_struct_field("lines", 3, |d| {
let num_lines: u32 = Decodable::decode(d)?;
let mut lines = Vec::with_capacity(num_lines as usize);
let num_lines: u32 = Decodable::decode(d)?;
let mut lines = Vec::with_capacity(num_lines as usize);
if num_lines > 0 {
// Read the number of bytes used per diff.
let bytes_per_diff: u8 = Decodable::decode(d)?;
if num_lines > 0 {
// Read the number of bytes used per diff.
let bytes_per_diff: u8 = Decodable::decode(d)?;
// Read the first element.
let mut line_start: BytePos = Decodable::decode(d)?;
lines.push(line_start);
for _ in 1..num_lines {
let diff = match bytes_per_diff {
1 => d.read_u8()? as u32,
2 => d.read_u16()? as u32,
4 => d.read_u32()?,
_ => unreachable!()
};
line_start = line_start + BytePos(diff);
// Read the first element.
let mut line_start: BytePos = Decodable::decode(d)?;
lines.push(line_start);
for _ in 1..num_lines {
let diff = match bytes_per_diff {
1 => d.read_u8()? as u32,
2 => d.read_u16()? as u32,
4 => d.read_u32()?,
_ => unreachable!()
};
line_start = line_start + BytePos(diff);
lines.push(line_start);
}
}
}
Ok(lines)
})?;
Ok(lines)
})?;
let multibyte_chars: Vec<MultiByteChar> =
d.read_struct_field("multibyte_chars", 4, |d| Decodable::decode(d))?;
Ok(FileMap {

24
src/libsyntax/errors/emitter.rs
View file

@ -208,8 +208,8 @@ impl EmitterWriter {
if let Some(_) = self.registry.as_ref()
.and_then(|registry| registry.find_description(code)) {
print_diagnostic(&mut self.dst, &ss[..], Help,
&format!("run `rustc --explain {}` to see a \
detailed explanation", code), None)?;
&format!("run `rustc --explain {}` to see a \
detailed explanation", code), None)?;
}
}
Ok(())
@ -234,13 +234,13 @@ impl EmitterWriter {
let mut lines = complete.lines();
for line in lines.by_ref().take(MAX_HIGHLIGHT_LINES) {
write!(&mut self.dst, "{0}:{1:2$} {3}\n",
fm.name, "", max_digits, line)?;
fm.name, "", max_digits, line)?;
}
// if we elided some lines, add an ellipsis
if let Some(_) = lines.next() {
write!(&mut self.dst, "{0:1$} {0:2$} ...\n",
"", fm.name.len(), max_digits)?;
"", fm.name.len(), max_digits)?;
}
Ok(())
@ -424,15 +424,15 @@ impl EmitterWriter {
// Print offending code-line
remaining_err_lines -= 1;
write!(&mut self.dst, "{}:{:>width$} {}\n",
fm.name,
line.line_index + 1,
cur_line_str,
width=digits)?;
fm.name,
line.line_index + 1,
cur_line_str,
width=digits)?;
if s.len() > skip {
// Render the spans we assembled previously (if any).
println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()),
"{}", s)?;
"{}", s)?;
}
if !overflowed_buf.is_empty() {
@ -561,13 +561,13 @@ impl EmitterWriter {
// Print offending code-lines
write!(&mut self.dst, "{}:{:>width$} {}\n", fm.name,
line.line_index + 1, line_str, width=digits)?;
line.line_index + 1, line_str, width=digits)?;
remaining_err_lines -= 1;
if s.len() > skip {
// Render the spans we assembled previously (if any)
println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()),
"{}", s)?;
"{}", s)?;
}
prev_line_index = line.line_index;
}
@ -642,7 +642,7 @@ fn print_diagnostic(dst: &mut Destination,
}
print_maybe_styled!(dst, term::Attr::ForegroundColor(lvl.color()),
"{}: ", lvl.to_string())?;
"{}: ", lvl.to_string())?;
print_maybe_styled!(dst, term::Attr::Bold, "{}", msg)?;
if let Some(code) = code {

41
src/libsyntax/parse/parser.rs
View file

@ -834,7 +834,7 @@ impl<'a> Parser<'a> {
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
let (result, returned) = self.parse_seq_to_before_gt_or_return(sep,
|p| Ok(Some(f(p)?)))?;
|p| Ok(Some(f(p)?)))?;
assert!(!returned);
return Ok(result);
}
@ -1476,8 +1476,8 @@ impl<'a> Parser<'a> {
self.bump();
let delim = self.expect_open_delim()?;
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(),
|p| p.parse_token_tree())?;
SeqSep::none(),
|p| p.parse_token_tree())?;
let hi = self.span.hi;
TyKind::Mac(spanned(lo, hi, Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT }))
} else {
@ -2225,7 +2225,7 @@ impl<'a> Parser<'a> {
&token::CloseDelim(token::Bracket),
SeqSep::trailing_allowed(token::Comma),
|p| Ok(p.parse_expr()?)
)?;
)?;
let mut exprs = vec!(first_expr);
exprs.extend(remaining_exprs);
ex = ExprKind::Vec(exprs);
@ -2610,8 +2610,8 @@ impl<'a> Parser<'a> {
let dot_pos = self.last_span.hi;
e = self.parse_dot_suffix(special_idents::invalid,
mk_sp(dot_pos, dot_pos),
e, lo)?;
mk_sp(dot_pos, dot_pos),
e, lo)?;
}
}
continue;
@ -3267,7 +3267,7 @@ impl<'a> Parser<'a> {
let match_span = self.last_span;
let lo = self.last_span.lo;
let discriminant = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL,
None)?;
None)?;
if let Err(mut e) = self.commit_expr_expecting(&discriminant,
token::OpenDelim(token::Brace)) {
if self.token == token::Token::Semi {
@ -3612,8 +3612,9 @@ impl<'a> Parser<'a> {
let path = ident_to_path(ident_span, ident);
self.bump();
let delim = self.expect_open_delim()?;
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(), |p| p.parse_token_tree())?;
let tts = self.parse_seq_to_end(
&token::CloseDelim(delim),
SeqSep::none(), |p| p.parse_token_tree())?;
let mac = Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT };
pat = PatKind::Mac(codemap::Spanned {node: mac,
span: mk_sp(lo, self.last_span.hi)});
@ -3670,10 +3671,10 @@ impl<'a> Parser<'a> {
pat = PatKind::TupleStruct(path, None);
} else {
let args = self.parse_enum_variant_seq(
&token::OpenDelim(token::Paren),
&token::CloseDelim(token::Paren),
SeqSep::trailing_allowed(token::Comma),
|p| p.parse_pat())?;
&token::OpenDelim(token::Paren),
&token::CloseDelim(token::Paren),
SeqSep::trailing_allowed(token::Comma),
|p| p.parse_pat())?;
pat = PatKind::TupleStruct(path, Some(args));
}
}
@ -3963,7 +3964,7 @@ impl<'a> Parser<'a> {
// FIXME: Bad copy of attrs
let restrictions = self.restrictions | Restrictions::NO_NONINLINE_MOD;
match self.with_res(restrictions,
|this| this.parse_item_(attrs.clone(), false, true))? {
|this| this.parse_item_(attrs.clone(), false, true))? {
Some(i) => {
let hi = i.span.hi;
let decl = P(spanned(lo, hi, DeclKind::Item(i)));
@ -4941,8 +4942,8 @@ impl<'a> Parser<'a> {
// eat a matched-delimiter token tree:
let delim = self.expect_open_delim()?;
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(),
|p| p.parse_token_tree())?;
SeqSep::none(),
|p| p.parse_token_tree())?;
let m_ = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT };
let m: ast::Mac = codemap::Spanned { node: m_,
span: mk_sp(lo,
@ -5409,8 +5410,8 @@ impl<'a> Parser<'a> {
id_sp: Span)
-> PResult<'a, (ast::ItemKind, Vec<ast::Attribute> )> {
let ModulePathSuccess { path, owns_directory } = self.submod_path(id,
outer_attrs,
id_sp)?;
outer_attrs,
id_sp)?;
self.eval_src_mod_from_path(path,
owns_directory,
@ -5993,8 +5994,8 @@ impl<'a> Parser<'a> {
// eat a matched-delimiter token tree:
let delim = self.expect_open_delim()?;
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(),
|p| p.parse_token_tree())?;
SeqSep::none(),
|p| p.parse_token_tree())?;
// single-variant-enum... :
let m = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT };
let m: ast::Mac = codemap::Spanned { node: m,

76
src/libsyntax/print/pprust.rs
View file

@ -388,7 +388,7 @@ pub fn fun_to_string(decl: &ast::FnDecl,
to_string(|s| {
s.head("")?;
s.print_fn(decl, unsafety, constness, Abi::Rust, Some(name),
generics, opt_explicit_self, ast::Visibility::Inherited)?;
generics, opt_explicit_self, ast::Visibility::Inherited)?;
s.end()?; // Close the head box
s.end() // Close the outer box
})
@ -779,8 +779,8 @@ pub trait PrintState<'a> {
word(self.writer(), &name)?;
self.popen()?;
self.commasep(Consistent,
&items[..],
|s, i| s.print_meta_item(&i))?;
&items[..],
|s, i| s.print_meta_item(&i))?;
self.pclose()?;
}
}
@ -915,7 +915,7 @@ impl<'a> State<'a> {
if i < len {
word(&mut self.s, ",")?;
self.maybe_print_trailing_comment(get_span(elt),
Some(get_span(&elts[i]).hi))?;
Some(get_span(&elts[i]).hi))?;
self.space_if_not_bol()?;
}
}
@ -979,7 +979,7 @@ impl<'a> State<'a> {
ast::TyKind::Tup(ref elts) => {
self.popen()?;
self.commasep(Inconsistent, &elts[..],
|s, ty| s.print_type(&ty))?;
|s, ty| s.print_type(&ty))?;
if elts.len() == 1 {
word(&mut self.s, ",")?;
}
@ -1000,11 +1000,11 @@ impl<'a> State<'a> {
},
};
self.print_ty_fn(f.abi,
f.unsafety,
&f.decl,
None,
&generics,
None)?;
f.unsafety,
&f.decl,
None,
&generics,
None)?;
}
ast::TyKind::Path(None, ref path) => {
self.print_path(path, false, 0)?;
@ -1050,16 +1050,15 @@ impl<'a> State<'a> {
ast::ForeignItemKind::Fn(ref decl, ref generics) => {
self.head("")?;
self.print_fn(decl, ast::Unsafety::Normal,
ast::Constness::NotConst,
Abi::Rust, Some(item.ident),
generics, None, item.vis)?;
ast::Constness::NotConst,
Abi::Rust, Some(item.ident),
generics, None, item.vis)?;
self.end()?; // end head-ibox
word(&mut self.s, ";")?;
self.end() // end the outer fn box
}
ast::ForeignItemKind::Static(ref t, m) => {
self.head(&visibility_qualified(item.vis,
"static"))?;
self.head(&visibility_qualified(item.vis, "static"))?;
if m {
self.word_space("mut")?;
}
@ -1119,8 +1118,7 @@ impl<'a> State<'a> {
self.ann.pre(self, NodeItem(item))?;
match item.node {
ast::ItemKind::ExternCrate(ref optional_path) => {
self.head(&visibility_qualified(item.vis,
"extern crate"))?;
self.head(&visibility_qualified(item.vis, "extern crate"))?;
if let Some(p) = *optional_path {
let val = p.as_str();
if val.contains("-") {
@ -1138,16 +1136,14 @@ impl<'a> State<'a> {
self.end()?; // end outer head-block
}
ast::ItemKind::Use(ref vp) => {
self.head(&visibility_qualified(item.vis,
"use"))?;
self.head(&visibility_qualified(item.vis, "use"))?;
self.print_view_path(&vp)?;
word(&mut self.s, ";")?;
self.end()?; // end inner head-block
self.end()?; // end outer head-block
}
ast::ItemKind::Static(ref ty, m, ref expr) => {
self.head(&visibility_qualified(item.vis,
"static"))?;
self.head(&visibility_qualified(item.vis, "static"))?;
if m == ast::Mutability::Mutable {
self.word_space("mut")?;
}
@ -1163,8 +1159,7 @@ impl<'a> State<'a> {
self.end()?; // end the outer cbox
}
ast::ItemKind::Const(ref ty, ref expr) => {
self.head(&visibility_qualified(item.vis,
"const"))?;
self.head(&visibility_qualified(item.vis, "const"))?;
self.print_ident(item.ident)?;
self.word_space(":")?;
self.print_type(&ty)?;
@ -1192,8 +1187,7 @@ impl<'a> State<'a> {
self.print_block_with_attrs(&body, &item.attrs)?;
}
ast::ItemKind::Mod(ref _mod) => {
self.head(&visibility_qualified(item.vis,
"mod"))?;
self.head(&visibility_qualified(item.vis, "mod"))?;
self.print_ident(item.ident)?;
self.nbsp()?;
self.bopen()?;
@ -1555,8 +1549,8 @@ impl<'a> State<'a> {
match ti.node {
ast::TraitItemKind::Const(ref ty, ref default) => {
self.print_associated_const(ti.ident, &ty,
default.as_ref().map(|expr| &**expr),
ast::Visibility::Inherited)?;
default.as_ref().map(|expr| &**expr),
ast::Visibility::Inherited)?;
}
ast::TraitItemKind::Method(ref sig, ref body) => {
if body.is_some() {
@ -1572,7 +1566,7 @@ impl<'a> State<'a> {
}
ast::TraitItemKind::Type(ref bounds, ref default) => {
self.print_associated_type(ti.ident, Some(bounds),
default.as_ref().map(|ty| &**ty))?;
default.as_ref().map(|ty| &**ty))?;
}
}
self.ann.post(self, NodeSubItem(ti.id))
@ -1923,7 +1917,7 @@ impl<'a> State<'a> {
if !tys.is_empty() {
word(&mut self.s, "::<")?;
self.commasep(Inconsistent, tys,
|s, ty| s.print_type(&ty))?;
|s, ty| s.print_type(&ty))?;
word(&mut self.s, ">")?;
}
self.print_call_post(base_args)
@ -2223,7 +2217,7 @@ impl<'a> State<'a> {
match out.constraint.slice_shift_char() {
Some(('=', operand)) if out.is_rw => {
s.print_string(&format!("+{}", operand),
ast::StrStyle::Cooked)?
ast::StrStyle::Cooked)?
}
_ => s.print_string(&out.constraint, ast::StrStyle::Cooked)?
}
@ -2267,10 +2261,10 @@ impl<'a> State<'a> {
space(&mut self.s)?;
self.word_space(":")?;
self.commasep(Inconsistent, &options,
|s, &co| {
s.print_string(co, ast::StrStyle::Cooked)?;
Ok(())
})?;
|s, &co| {
s.print_string(co, ast::StrStyle::Cooked)?;
Ok(())
})?;
}
self.pclose()?;
@ -3037,13 +3031,13 @@ impl<'a> State<'a> {
},
};
self.print_fn(decl,
unsafety,
ast::Constness::NotConst,
abi,
name,
&generics,
opt_explicit_self,
ast::Visibility::Inherited)?;
unsafety,
ast::Constness::NotConst,
abi,
name,
&generics,
opt_explicit_self,
ast::Visibility::Inherited)?;
self.end()
}

4
src/tools/error_index_generator/main.rs
View file

@ -96,8 +96,8 @@ impl Formatter for HTMLFormatter {
// Error title (with self-link).
write!(output,
"<h2 id=\"{0}\" class=\"section-header\"><a href=\"#{0}\">{0}</a></h2>\n",
err_code)?;
"<h2 id=\"{0}\" class=\"section-header\"><a href=\"#{0}\">{0}</a></h2>\n",
err_code)?;
// Description rendered as markdown.
match info.description {

8
src/tools/rustbook/build.rs
View file

@ -56,10 +56,10 @@ fn write_toc(book: &Book, current_page: &BookItem, out: &mut Write) -> io::Resul
};
writeln!(out, "<li><a {} href='{}'><b>{}</b> {}</a>",
class_string,
current_page.path_to_root.join(&item.path).with_extension("html").display(),
section,
item.title)?;
class_string,
current_page.path_to_root.join(&item.path).with_extension("html").display(),
section,
item.title)?;
if !item.children.is_empty() {
writeln!(out, "<ul class='section'>")?;
let _ = walk_items(&item.children[..], section, current_page, out);