use syntax::abi;
use syntax::ast;
-use syntax::owned_slice::OwnedSlice;
use syntax::codemap::{self, CodeMap, BytePos, Spanned};
-use syntax::diagnostic;
+use syntax::errors;
use syntax::parse::token::{self, BinOpToken};
use syntax::parse::lexer::comments;
use syntax::parse;
use syntax::ptr::P;
use hir;
-use hir::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
+use hir::{Crate, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use std::io::{self, Write, Read};
pub struct State<'a> {
+ krate: Option<&'a Crate>,
pub s: pp::Printer<'a>,
cm: Option<&'a CodeMap>,
comments: Option<Vec<comments::Comment>>,
}
}
-pub fn rust_printer<'a>(writer: Box<Write + 'a>) -> State<'a> {
+pub fn rust_printer<'a>(writer: Box<Write + 'a>, krate: Option<&'a Crate>) -> State<'a> {
static NO_ANN: NoAnn = NoAnn;
- rust_printer_annotated(writer, &NO_ANN)
+ rust_printer_annotated(writer, &NO_ANN, krate)
}
-pub fn rust_printer_annotated<'a>(writer: Box<Write + 'a>, ann: &'a PpAnn) -> State<'a> {
+pub fn rust_printer_annotated<'a>(writer: Box<Write + 'a>,
+ ann: &'a PpAnn,
+ krate: Option<&'a Crate>)
+ -> State<'a> {
State {
+ krate: krate,
s: pp::mk_printer(writer, default_columns),
cm: None,
comments: None,
/// it can scan the input text for comments and literals to
/// copy forward.
pub fn print_crate<'a>(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
krate: &hir::Crate,
filename: String,
input: &mut Read,
ann: &'a PpAnn,
is_expanded: bool)
-> io::Result<()> {
- let mut s = State::new_from_input(cm, span_diagnostic, filename, input, out, ann, is_expanded);
+ let mut s = State::new_from_input(cm, span_diagnostic, filename, input,
+ out, ann, is_expanded, Some(krate));
// When printing the AST, we sometimes need to inject `#[no_std]` here.
// Since you can't compile the HIR, it's not necessary.
impl<'a> State<'a> {
pub fn new_from_input(cm: &'a CodeMap,
- span_diagnostic: &diagnostic::SpanHandler,
+ span_diagnostic: &errors::Handler,
filename: String,
input: &mut Read,
out: Box<Write + 'a>,
ann: &'a PpAnn,
- is_expanded: bool)
+ is_expanded: bool,
+ krate: Option<&'a Crate>)
-> State<'a> {
let (cmnts, lits) = comments::gather_comments_and_literals(span_diagnostic,
filename,
None
} else {
Some(lits)
- })
+ },
+ krate)
}
pub fn new(cm: &'a CodeMap,
out: Box<Write + 'a>,
ann: &'a PpAnn,
comments: Option<Vec<comments::Comment>>,
- literals: Option<Vec<comments::Literal>>)
+ literals: Option<Vec<comments::Literal>>,
+ krate: Option<&'a Crate>)
-> State<'a> {
State {
+ krate: krate,
s: pp::mk_printer(out, default_columns),
cm: Some(cm),
comments: comments.clone(),
{
let mut wr = Vec::new();
{
- let mut printer = rust_printer(Box::new(&mut wr));
+ let mut printer = rust_printer(Box::new(&mut wr), None);
f(&mut printer).unwrap();
eof(&mut printer.s).unwrap();
}
pub fn print_mod(&mut self, _mod: &hir::Mod, attrs: &[ast::Attribute]) -> io::Result<()> {
try!(self.print_inner_attributes(attrs));
- for item in &_mod.items {
- try!(self.print_item(&**item));
+ for item_id in &_mod.item_ids {
+ try!(self.print_item_id(item_id));
}
Ok(())
}
-> io::Result<()> {
try!(self.print_inner_attributes(attrs));
for item in &nmod.items {
- try!(self.print_foreign_item(&**item));
+ try!(self.print_foreign_item(item));
}
Ok(())
}
}
try!(self.pclose());
}
- hir::TyParen(ref typ) => {
- try!(self.popen());
- try!(self.print_type(&**typ));
- try!(self.pclose());
- }
hir::TyBareFn(ref f) => {
let generics = hir::Generics {
lifetimes: f.lifetimes.clone(),
- ty_params: OwnedSlice::empty(),
+ ty_params: P::empty(),
where_clause: hir::WhereClause {
id: ast::DUMMY_NODE_ID,
- predicates: Vec::new(),
+ predicates: hir::HirVec::new(),
},
};
try!(self.print_ty_fn(f.abi, f.unsafety, &*f.decl, None, &generics, None));
word(&mut self.s, ";")
}
+ pub fn print_item_id(&mut self, item_id: &hir::ItemId) -> io::Result<()> {
+ if let Some(krate) = self.krate {
+ // skip nested items if krate context was not provided
+ let item = &krate.items[&item_id.id];
+ self.print_item(item)
+ } else {
+ Ok(())
+ }
+ }
+
/// Pretty-print an item
pub fn print_item(&mut self, item: &hir::Item) -> io::Result<()> {
try!(self.hardbreak_if_not_bol());
}
pub fn print_variants(&mut self,
- variants: &[P<hir::Variant>],
+ variants: &[hir::Variant],
span: codemap::Span)
-> io::Result<()> {
try!(self.bopen());
try!(self.maybe_print_comment(v.span.lo));
try!(self.print_outer_attributes(&v.node.attrs));
try!(self.ibox(indent_unit));
- try!(self.print_variant(&**v));
+ try!(self.print_variant(v));
try!(word(&mut self.s, ","));
try!(self.end());
try!(self.maybe_print_trailing_comment(v.span, None));
try!(self.maybe_print_comment(ii.span.lo));
try!(self.print_outer_attributes(&ii.attrs));
match ii.node {
- hir::ImplItem_::Const(ref ty, ref expr) => {
+ hir::ImplItemKind::Const(ref ty, ref expr) => {
try!(self.print_associated_const(ii.name, &ty, Some(&expr), ii.vis));
}
- hir::ImplItem_::Method(ref sig, ref body) => {
+ hir::ImplItemKind::Method(ref sig, ref body) => {
try!(self.head(""));
try!(self.print_method_sig(ii.name, sig, ii.vis));
try!(self.nbsp());
try!(self.print_block_with_attrs(body, &ii.attrs));
}
- hir::ImplItem_::Type(ref ty) => {
+ hir::ImplItemKind::Type(ref ty) => {
try!(self.print_associated_type(ii.name, None, Some(ty)));
}
}
try!(self.print_inner_attributes(attrs));
for st in &blk.stmts {
- try!(self.print_stmt(&**st));
+ try!(self.print_stmt(st));
}
match blk.expr {
Some(ref expr) => {
try!(self.print_string(&a.asm, a.asm_str_style));
try!(self.word_space(":"));
- try!(self.commasep(Inconsistent, &a.outputs, |s, &(ref co, ref o, is_rw)| {
- match co.slice_shift_char() {
- Some(('=', operand)) if is_rw => {
+ try!(self.commasep(Inconsistent, &a.outputs, |s, out| {
+ match out.constraint.slice_shift_char() {
+ Some(('=', operand)) if out.is_rw => {
try!(s.print_string(&format!("+{}", operand), ast::CookedStr))
}
- _ => try!(s.print_string(&co, ast::CookedStr)),
+ _ => try!(s.print_string(&out.constraint, ast::CookedStr)),
}
try!(s.popen());
- try!(s.print_expr(&**o));
+ try!(s.print_expr(&*out.expr));
try!(s.pclose());
Ok(())
}));
}
self.end()
}
- hir::DeclItem(ref item) => self.print_item(&**item),
+ hir::DeclItem(ref item) => {
+ self.print_item_id(item)
+ }
}
}
try!(self.print_generics(generics));
}
let generics = hir::Generics {
- lifetimes: Vec::new(),
- ty_params: OwnedSlice::empty(),
+ lifetimes: hir::HirVec::new(),
+ ty_params: P::empty(),
where_clause: hir::WhereClause {
id: ast::DUMMY_NODE_ID,
- predicates: Vec::new(),
+ predicates: hir::HirVec::new(),
},
};
try!(self.print_fn(decl,