#[derive(Copy)]
pub struct CurrentCommentAndLiteral {
- cur_cmnt: uint,
- cur_lit: uint,
+ cur_cmnt: usize,
+ cur_lit: usize,
}
pub struct State<'a> {
}
#[allow(non_upper_case_globals)]
-pub const indent_unit: uint = 4u;
+pub const indent_unit: usize = 4us;
#[allow(non_upper_case_globals)]
-pub const default_columns: uint = 78u;
+pub const default_columns: usize = 78us;
/// Requires you to pass an input filename and reader so that
/// it can scan the input text for comments and literals to
$to_string(|s| s.print_item(i))
}
-pub fn view_item_to_string(i: &ast::ViewItem) -> String {
- $to_string(|s| s.print_view_item(i))
-}
-
pub fn generics_to_string(generics: &ast::Generics) -> String {
$to_string(|s| s.print_generics(generics))
}
// containing cbox, will be closed by print-block at }
try!(s.cbox(indent_unit));
// head-ibox, will be closed by print-block after {
- try!(s.ibox(0u));
+ try!(s.ibox(0us));
s.print_block(blk)
})
}
}
impl<'a> State<'a> {
- pub fn ibox(&mut self, u: uint) -> IoResult<()> {
+ pub fn ibox(&mut self, u: usize) -> IoResult<()> {
self.boxes.push(pp::Breaks::Inconsistent);
pp::ibox(&mut self.s, u)
}
pp::end(&mut self.s)
}
- pub fn cbox(&mut self, u: uint) -> IoResult<()> {
+ pub fn cbox(&mut self, u: usize) -> IoResult<()> {
self.boxes.push(pp::Breaks::Consistent);
pp::cbox(&mut self.s, u)
}
// "raw box"
- pub fn rbox(&mut self, u: uint, b: pp::Breaks) -> IoResult<()> {
+ pub fn rbox(&mut self, u: usize, b: pp::Breaks) -> IoResult<()> {
self.boxes.push(b);
pp::rbox(&mut self.s, u, b)
}
}
pub fn bclose_(&mut self, span: codemap::Span,
- indented: uint) -> IoResult<()> {
+ indented: usize) -> IoResult<()> {
self.bclose_maybe_open(span, indented, true)
}
pub fn bclose_maybe_open (&mut self, span: codemap::Span,
- indented: uint, close_box: bool) -> IoResult<()> {
+ indented: usize, close_box: bool) -> IoResult<()> {
try!(self.maybe_print_comment(span.hi));
- try!(self.break_offset_if_not_bol(1u, -(indented as int)));
+ try!(self.break_offset_if_not_bol(1us, -(indented as isize)));
try!(word(&mut self.s, "}"));
if close_box {
try!(self.end()); // close the outer-box
if !self.is_bol() { try!(space(&mut self.s)); }
Ok(())
}
- pub fn break_offset_if_not_bol(&mut self, n: uint,
- off: int) -> IoResult<()> {
+ pub fn break_offset_if_not_bol(&mut self, n: usize,
+ off: isize) -> IoResult<()> {
if !self.is_bol() {
break_offset(&mut self.s, n, off)
} else {
pub fn commasep<T, F>(&mut self, b: Breaks, elts: &[T], mut op: F) -> IoResult<()> where
F: FnMut(&mut State, &T) -> IoResult<()>,
{
- try!(self.rbox(0u, b));
+ try!(self.rbox(0us, b));
let mut first = true;
for elt in elts.iter() {
if first { first = false; } else { try!(self.word_space(",")); }
F: FnMut(&mut State, &T) -> IoResult<()>,
G: FnMut(&T) -> codemap::Span,
{
- try!(self.rbox(0u, b));
+ try!(self.rbox(0us, b));
let len = elts.len();
- let mut i = 0u;
+ let mut i = 0us;
for elt in elts.iter() {
try!(self.maybe_print_comment(get_span(elt).hi));
try!(op(self, elt));
- i += 1u;
+ i += 1us;
if i < len {
try!(word(&mut self.s, ","));
try!(self.maybe_print_trailing_comment(get_span(elt),
pub fn print_mod(&mut self, _mod: &ast::Mod,
attrs: &[ast::Attribute]) -> IoResult<()> {
try!(self.print_inner_attributes(attrs));
- for vitem in _mod.view_items.iter() {
- try!(self.print_view_item(vitem));
- }
for item in _mod.items.iter() {
try!(self.print_item(&**item));
}
pub fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod,
attrs: &[ast::Attribute]) -> IoResult<()> {
try!(self.print_inner_attributes(attrs));
- for vitem in nmod.view_items.iter() {
- try!(self.print_view_item(vitem));
- }
for item in nmod.items.iter() {
try!(self.print_foreign_item(&**item));
}
pub fn print_type(&mut self, ty: &ast::Ty) -> IoResult<()> {
try!(self.maybe_print_comment(ty.span.lo));
- try!(self.ibox(0u));
+ try!(self.ibox(0us));
match ty.node {
ast::TyVec(ref ty) => {
try!(word(&mut self.s, "["));
try!(self.print_outer_attributes(&item.attrs[]));
try!(self.ann.pre(self, NodeItem(item)));
match item.node {
+ ast::ItemExternCrate(ref optional_path) => {
+ try!(self.head(&visibility_qualified(item.vis,
+ "extern crate")[]));
+ for &(ref p, style) in optional_path.iter() {
+ try!(self.print_string(p.get(), style));
+ try!(space(&mut self.s));
+ try!(word(&mut self.s, "as"));
+ try!(space(&mut self.s));
+ }
+ try!(self.print_ident(item.ident));
+ try!(word(&mut self.s, ";"));
+ try!(self.end()); // end inner head-block
+ try!(self.end()); // end outer head-block
+ }
+ ast::ItemUse(ref vp) => {
+ try!(self.head(&visibility_qualified(item.vis,
+ "use")[]));
+ try!(self.print_view_path(&**vp));
+ try!(word(&mut self.s, ";"));
+ try!(self.end()); // end inner head-block
+ try!(self.end()); // end outer head-block
+ }
ast::ItemStatic(ref ty, m, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"static")[]));
}
ast::ItemTy(ref ty, ref params) => {
try!(self.ibox(indent_unit));
- try!(self.ibox(0u));
+ try!(self.ibox(0us));
try!(self.word_nbsp(&visibility_qualified(item.vis, "type")[]));
try!(self.print_ident(item.ident));
try!(self.print_generics(params));
pub fn print_tts(&mut self, tts: &[ast::TokenTree]) -> IoResult<()> {
try!(self.ibox(0));
+ let mut suppress_space = false;
for (i, tt) in tts.iter().enumerate() {
- if i != 0 {
+ if i != 0 && !suppress_space {
try!(space(&mut self.s));
}
try!(self.print_tt(tt));
+ // There should be no space between the module name and the following `::` in paths,
+ // otherwise imported macros get re-parsed from crate metadata incorrectly (#20701)
+ suppress_space = match tt {
+ &ast::TtToken(_, token::Ident(_, token::ModName)) |
+ &ast::TtToken(_, token::MatchNt(_, _, _, token::ModName)) |
+ &ast::TtToken(_, token::SubstNt(_, token::ModName)) => true,
+ _ => false
+ }
}
self.end()
}
pub fn print_outer_attributes(&mut self,
attrs: &[ast::Attribute]) -> IoResult<()> {
- let mut count = 0u;
+ let mut count = 0us;
for attr in attrs.iter() {
match attr.node.style {
ast::AttrOuter => {
pub fn print_inner_attributes(&mut self,
attrs: &[ast::Attribute]) -> IoResult<()> {
- let mut count = 0u;
+ let mut count = 0us;
for attr in attrs.iter() {
match attr.node.style {
ast::AttrInner => {
}
pub fn print_block_unclosed_indent(&mut self, blk: &ast::Block,
- indented: uint) -> IoResult<()> {
+ indented: usize) -> IoResult<()> {
self.print_block_maybe_unclosed(blk, indented, &[], false)
}
pub fn print_block_maybe_unclosed(&mut self,
blk: &ast::Block,
- indented: uint,
+ indented: usize,
attrs: &[ast::Attribute],
close_box: bool) -> IoResult<()> {
match blk.rules {
try!(self.print_inner_attributes(attrs));
- for vi in blk.view_items.iter() {
- try!(self.print_view_item(vi));
- }
for st in blk.stmts.iter() {
try!(self.print_stmt(&**st));
}
match _else.node {
// "another else-if"
ast::ExprIf(ref i, ref then, ref e) => {
- try!(self.cbox(indent_unit - 1u));
- try!(self.ibox(0u));
+ try!(self.cbox(indent_unit - 1us));
+ try!(self.ibox(0us));
try!(word(&mut self.s, " else if "));
try!(self.print_expr(&**i));
try!(space(&mut self.s));
}
// "another else-if-let"
ast::ExprIfLet(ref pat, ref expr, ref then, ref e) => {
- try!(self.cbox(indent_unit - 1u));
- try!(self.ibox(0u));
+ try!(self.cbox(indent_unit - 1us));
+ try!(self.ibox(0us));
try!(word(&mut self.s, " else if let "));
try!(self.print_pat(&**pat));
try!(space(&mut self.s));
}
// "final else"
ast::ExprBlock(ref b) => {
- try!(self.cbox(indent_unit - 1u));
- try!(self.ibox(0u));
+ try!(self.cbox(indent_unit - 1us));
+ try!(self.ibox(0us));
try!(word(&mut self.s, " else "));
self.print_block(&**b)
}
ident: ast::SpannedIdent,
tys: &[P<ast::Ty>],
args: &[P<ast::Expr>]) -> IoResult<()> {
- let base_args = args.slice_from(1);
+ let base_args = &args[1..];
try!(self.print_expr(&*args[0]));
try!(word(&mut self.s, "."));
try!(self.print_ident(ident.node));
- if tys.len() > 0u {
+ if tys.len() > 0us {
try!(word(&mut self.s, "::<"));
try!(self.commasep(Inconsistent, tys,
|s, ty| s.print_type(&**ty)));
// containing cbox, will be closed by print-block at }
try!(self.cbox(indent_unit));
// head-box, will be closed by print-block after {
- try!(self.ibox(0u));
+ try!(self.ibox(0us));
try!(self.print_block(&**blk));
}
ast::ExprAssign(ref lhs, ref rhs) => {
ast::ExprTupField(ref expr, id) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "."));
- try!(self.print_uint(id.node));
+ try!(self.print_usize(id.node));
}
ast::ExprIndex(ref expr, ref index) => {
try!(self.print_expr(&**expr));
self.ann.post(self, NodeIdent(&ident))
}
- pub fn print_uint(&mut self, i: uint) -> IoResult<()> {
+ pub fn print_usize(&mut self, i: usize) -> IoResult<()> {
word(&mut self.s, &i.to_string()[])
}
},
|f| f.node.pat.span));
if etc {
- if fields.len() != 0u { try!(self.word_space(",")); }
+ if fields.len() != 0us { try!(self.word_space(",")); }
try!(word(&mut self.s, ".."));
}
try!(space(&mut self.s));
try!(space(&mut self.s));
}
try!(self.cbox(indent_unit));
- try!(self.ibox(0u));
+ try!(self.ibox(0us));
try!(self.print_outer_attributes(&arm.attrs[]));
let mut first = true;
for p in arm.pats.iter() {
-> IoResult<()> {
// It is unfortunate to duplicate the commasep logic, but we want the
// self type and the args all in the same box.
- try!(self.rbox(0u, Inconsistent));
+ try!(self.rbox(0us, Inconsistent));
let mut first = true;
for &explicit_self in opt_explicit_self.iter() {
let m = match explicit_self {
let args = if first {
&decl.inputs[]
} else {
- decl.inputs.slice_from(1)
+ &decl.inputs[1..]
};
for arg in args.iter() {
try!(word(&mut self.s, "<"));
let mut ints = Vec::new();
- for i in range(0u, total) {
+ for i in range(0us, total) {
ints.push(i);
}
pub fn print_view_path(&mut self, vp: &ast::ViewPath) -> IoResult<()> {
match vp.node {
- ast::ViewPathSimple(ident, ref path, _) => {
+ ast::ViewPathSimple(ident, ref path) => {
try!(self.print_path(path, false));
// FIXME(#6993) can't compare identifiers directly here
Ok(())
}
- ast::ViewPathGlob(ref path, _) => {
+ ast::ViewPathGlob(ref path) => {
try!(self.print_path(path, false));
word(&mut self.s, "::*")
}
- ast::ViewPathList(ref path, ref idents, _) => {
+ ast::ViewPathList(ref path, ref idents) => {
if path.segments.is_empty() {
try!(word(&mut self.s, "{"));
} else {
}
}
- pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> {
- try!(self.hardbreak_if_not_bol());
- try!(self.maybe_print_comment(item.span.lo));
- try!(self.print_outer_attributes(&item.attrs[]));
- try!(self.print_visibility(item.vis));
- match item.node {
- ast::ViewItemExternCrate(id, ref optional_path, _) => {
- try!(self.head("extern crate"));
- for &(ref p, style) in optional_path.iter() {
- try!(self.print_string(p.get(), style));
- try!(space(&mut self.s));
- try!(word(&mut self.s, "as"));
- try!(space(&mut self.s));
- }
- try!(self.print_ident(id));
- }
-
- ast::ViewItemUse(ref vp) => {
- try!(self.head("use"));
- try!(self.print_view_path(&**vp));
- }
- }
- try!(word(&mut self.s, ";"));
- try!(self.end()); // end inner head-block
- self.end() // end outer head-block
- }
-
pub fn print_mutability(&mut self,
mutbl: ast::Mutability) -> IoResult<()> {
match mutbl {
if span.hi < (*cmnt).pos && (*cmnt).pos < next &&
span_line.line == comment_line.line {
try!(self.print_comment(cmnt));
- self.cur_cmnt_and_lit.cur_cmnt += 1u;
+ self.cur_cmnt_and_lit.cur_cmnt += 1us;
}
}
_ => ()
match self.next_comment() {
Some(ref cmnt) => {
try!(self.print_comment(cmnt));
- self.cur_cmnt_and_lit.cur_cmnt += 1u;
+ self.cur_cmnt_and_lit.cur_cmnt += 1us;
}
_ => break
}
while self.cur_cmnt_and_lit.cur_lit < lits.len() {
let ltrl = (*lits)[self.cur_cmnt_and_lit.cur_lit].clone();
if ltrl.pos > pos { return None; }
- self.cur_cmnt_and_lit.cur_lit += 1u;
+ self.cur_cmnt_and_lit.cur_lit += 1us;
if ltrl.pos == pos { return Some(ltrl); }
}
None
Some(ref cmnt) => {
if (*cmnt).pos < pos {
try!(self.print_comment(cmnt));
- self.cur_cmnt_and_lit.cur_cmnt += 1u;
+ self.cur_cmnt_and_lit.cur_cmnt += 1us;
} else { break; }
}
_ => break
cmnt: &comments::Comment) -> IoResult<()> {
match cmnt.style {
comments::Mixed => {
- assert_eq!(cmnt.lines.len(), 1u);
+ assert_eq!(cmnt.lines.len(), 1us);
try!(zerobreak(&mut self.s));
try!(word(&mut self.s, &cmnt.lines[0][]));
zerobreak(&mut self.s)
}
comments::Trailing => {
try!(word(&mut self.s, " "));
- if cmnt.lines.len() == 1u {
+ if cmnt.lines.len() == 1us {
try!(word(&mut self.s, &cmnt.lines[0][]));
hardbreak(&mut self.s)
} else {
- try!(self.ibox(0u));
+ try!(self.ibox(0us));
for line in cmnt.lines.iter() {
if !line.is_empty() {
try!(word(&mut self.s, &line[]));
}
}
-fn repeat(s: &str, n: uint) -> String { iter::repeat(s).take(n).collect() }
+fn repeat(s: &str, n: usize) -> String { iter::repeat(s).take(n).collect() }
#[cfg(test)]
mod test {