} 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(())
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
// 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)) => {
// 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)) => {
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))?;
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))?;
}
(&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))) => {
// 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() ==
.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)
}
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,
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);
}
}
}
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)) =>
{
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(
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
})?;
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, "", ">");
}
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, "", ">")?;
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) => {
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))
}
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(())
}
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;
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(())
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)
};
};
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();
})?;
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));
};
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",
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
})
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
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)?;
}
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() {
}
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))
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)?;
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(",")?;
},
};
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()
}
// 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)?;
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, ">;")
// 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 {
}
Addition::Archive { archive, archive_name, mut skip } => {
self.add_archive_members(&mut members, archive,
- &archive_name, &mut *skip)?;
+ &archive_name, &mut *skip)?;
}
}
}
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) => {
}
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 { // |
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,
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(())
}
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);
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)?;
}
}
}
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)?,
}
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) => {
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 => {}
}
_ => {
primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
- &format!("*{}", RawMutableSpace(m)))?;
+ &format!("*{}", RawMutableSpace(m)))?;
write!(f, "{}", t)
}
}
primitive_link(f, clean::Slice,
&format!("&{}{}[{}]", lt, m, **bt)),
_ => {
- primitive_link(f, clean::Slice,
- &format!("&{}{}[", lt, m))?;
+ primitive_link(f, clean::Slice, &format!("&{}{}[", lt, m))?;
write!(f, "{}", **bt)?;
primitive_link(f, clean::Slice, "]")
}
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(())
},
token::Comment => {
write!(out, "<span class='comment'>{}</span>",
- Escape(&snip(next.sp)))?;
+ Escape(&snip(next.sp)))?;
continue
},
token::Shebang(s) => {
if klass == "" {
write!(out, "{}", Escape(&snip))?;
} else {
- write!(out, "<span class='{}'>{}</span>", klass,
- Escape(&snip))?;
+ write!(out, "<span class='{}'>{}</span>", klass, Escape(&snip))?;
}
}
// 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>> {
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(())
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>();
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'>−</span>]
- </a>
- </span>"##)?;
+ r##"<span id='render-detail'>
+
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
+ [<span class='inner'>−</span>]
+ </a>
+ </span>"##)?;
// Write `src` tag
//
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")?;
}
}
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 {
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>")?;
clean::ImportItem(ref import) => {
write!(w, "<tr><td><code>{}{}</code></td></tr>",
- VisSpace(myitem.visibility), *import)?;
+ VisSpace(myitem.visibility), *import)?;
}
_ => {
};
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))?;
}
}
}
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_,
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(),
_ => 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),
// 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<_>>();
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)?;
}
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(())
}
if let Some(v) = ver {
if containing_ver != ver && v.len() > 0 {
write!(w, "<span class=\"since\">{}</span>",
- v)?
+ v)?
}
}
Ok(())
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)?;
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>")?;
}
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 {
}
clean::StructVariant(ref s) => {
render_struct(w,
- v,
- None,
- s.struct_type,
- &s.fields,
- " ",
- false)?;
+ v,
+ None,
+ s.struct_type,
+ &s.fields,
+ " ",
+ false)?;
}
}
}
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};
}
});
write!(w, "<h3 class='fields'>Fields</h3>\n
+ <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>")?;
}
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))?
}
}
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!(),
};
}
AssocItemRender::DerefFor { trait_, type_ } => {
write!(w, "<h2 id='deref-methods'>Methods from \
- {}<Target={}></h2>", trait_, type_)?;
+ {}<Target={}></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 {
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())?;
}
}
}
}
doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static,
- outer_version)?;
+ outer_version)?;
}
Ok(())
}
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)
}
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(())
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)
}
// 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>")
}
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(())
}
}
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)
}
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 })
}
}
// 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
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))
}
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)
}
}
-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());
}
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,
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()
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,
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();
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)?;
-
- 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
- };
-
- // Encode the number of bytes used per diff.
- bytes_per_diff.encode(s)?;
-
- // Encode the first element.
- lines[0].encode(s)?;
-
- 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!()
- }
+ 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()
+ };
+
+ 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 first element.
+ lines[0].encode(s)?;
+
+ 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!()
}
+ }
- Ok(())
- })?;
+ Ok(())
+ })?;
s.emit_struct_field("multibyte_chars", 4, |s| {
(*self.multibyte_chars.borrow()).encode(s)
})
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)?;
+
+ // 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!()
+ };
- if num_lines > 0 {
- // Read the number of bytes used per diff.
- let bytes_per_diff: u8 = Decodable::decode(d)?;
+ 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 {
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(())
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(())
// 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() {
// 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;
}
}
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 {
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);
}
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 {
&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);
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;
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 {
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)});
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));
}
}
// 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)));
// 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,
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,
// 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,
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
})
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()?;
}
}
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()?;
}
}
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, ",")?;
}
},
};
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)?;
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")?;
}
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("-") {
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")?;
}
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)?;
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()?;
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() {
}
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))
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)
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)?
}
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()?;
},
};
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()
}
// 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 {
};
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);
projects / rust.git / commitdiff