// FIXME: remove this after snapshot, and Results are handled
#![allow(unused_must_use)]
-use ast_map;
+use front::map as ast_map;
+use rustc_front::hir;
+use rustc_front::fold;
+use rustc_front::fold::Folder;
+
use metadata::common as c;
use metadata::cstore as cstore;
use session::Session;
use metadata::tydecode::{DefIdSource, NominalType, TypeWithId};
use metadata::tydecode::{RegionParameter, ClosureSource};
use metadata::tyencode;
-use middle::cast;
+use middle::ty::adjustment;
+use middle::ty::cast;
use middle::check_const::ConstQualif;
use middle::def;
use middle::def_id::{DefId, LOCAL_CRATE};
use middle::subst::VecPerParamSpace;
use middle::ty::{self, Ty};
-use syntax::{ast, ast_util, codemap, fold};
+use syntax::{ast, ast_util, codemap};
use syntax::codemap::Span;
-use syntax::fold::Folder;
use syntax::ptr::P;
-use syntax;
use std::cell::Cell;
use std::io::SeekFrom;
#[cfg(test)] use std::io::Cursor;
#[cfg(test)] use syntax::parse;
-#[cfg(test)] use syntax::print::pprust;
+#[cfg(test)] use rustc_front::print::pprust;
+#[cfg(test)] use rustc_front::lowering::lower_item;
struct DecodeContext<'a, 'b, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
match *ii {
InlinedItem::Item(ref i) => {
debug!(">>> DECODED ITEM >>>\n{}\n<<< DECODED ITEM <<<",
- syntax::print::pprust::item_to_string(&**i));
+ ::rustc_front::print::pprust::item_to_string(&**i));
}
_ => { }
}
struct NestedItemsDropper;
impl Folder for NestedItemsDropper {
- fn fold_block(&mut self, blk: P<ast::Block>) -> P<ast::Block> {
- blk.and_then(|ast::Block {id, stmts, expr, rules, span, ..}| {
+ fn fold_block(&mut self, blk: P<hir::Block>) -> P<hir::Block> {
+ blk.and_then(|hir::Block {id, stmts, expr, rules, span, ..}| {
let stmts_sans_items = stmts.into_iter().filter_map(|stmt| {
let use_stmt = match stmt.node {
- ast::StmtExpr(_, _) | ast::StmtSemi(_, _) => true,
- ast::StmtDecl(ref decl, _) => {
+ hir::StmtExpr(_, _) | hir::StmtSemi(_, _) => true,
+ hir::StmtDecl(ref decl, _) => {
match decl.node {
- ast::DeclLocal(_) => true,
- ast::DeclItem(_) => false,
+ hir::DeclLocal(_) => true,
+ hir::DeclItem(_) => false,
}
}
- ast::StmtMac(..) => panic!("unexpanded macro in astencode")
};
if use_stmt {
Some(stmt)
None
}
}).collect();
- let blk_sans_items = P(ast::Block {
+ let blk_sans_items = P(hir::Block {
stmts: stmts_sans_items,
expr: expr,
id: id,
def::DefPrimTy(p) => def::DefPrimTy(p),
def::DefTyParam(s, index, def_id, n) => def::DefTyParam(s, index, def_id.tr(dcx), n),
def::DefUse(did) => def::DefUse(did.tr(dcx)),
- def::DefUpvar(nid1, nid2) => {
- def::DefUpvar(dcx.tr_id(nid1), dcx.tr_id(nid2))
+ def::DefUpvar(nid1, index, nid2) => {
+ def::DefUpvar(dcx.tr_id(nid1), index, dcx.tr_id(nid2))
}
def::DefStruct(did) => def::DefStruct(did.tr(dcx)),
def::DefRegion(nid) => def::DefRegion(dcx.tr_id(nid)),
trait rbml_decoder_helper {
fn read_freevar_entry(&mut self, dcx: &DecodeContext)
-> ty::Freevar;
- fn read_capture_mode(&mut self) -> ast::CaptureClause;
+ fn read_capture_mode(&mut self) -> hir::CaptureClause;
}
impl<'a> rbml_decoder_helper for reader::Decoder<'a> {
fv.tr(dcx)
}
- fn read_capture_mode(&mut self) -> ast::CaptureClause {
- let cm: ast::CaptureClause = Decodable::decode(self).unwrap();
+ fn read_capture_mode(&mut self) -> hir::CaptureClause {
+ let cm: hir::CaptureClause = Decodable::decode(self).unwrap();
cm
}
}
fn emit_builtin_bounds(&mut self, ecx: &e::EncodeContext, bounds: &ty::BuiltinBounds);
fn emit_upvar_capture(&mut self, ecx: &e::EncodeContext, capture: &ty::UpvarCapture);
fn emit_auto_adjustment<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
- adj: &ty::AutoAdjustment<'tcx>);
+ adj: &adjustment::AutoAdjustment<'tcx>);
fn emit_autoref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
- autoref: &ty::AutoRef<'tcx>);
+ autoref: &adjustment::AutoRef<'tcx>);
fn emit_auto_deref_ref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
- auto_deref_ref: &ty::AutoDerefRef<'tcx>);
+ auto_deref_ref: &adjustment::AutoDerefRef<'tcx>);
}
impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
}
fn emit_auto_adjustment<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
- adj: &ty::AutoAdjustment<'tcx>) {
+ adj: &adjustment::AutoAdjustment<'tcx>) {
use serialize::Encoder;
self.emit_enum("AutoAdjustment", |this| {
match *adj {
- ty::AdjustReifyFnPointer=> {
+ adjustment::AdjustReifyFnPointer=> {
this.emit_enum_variant("AdjustReifyFnPointer", 1, 0, |_| Ok(()))
}
- ty::AdjustUnsafeFnPointer => {
+ adjustment::AdjustUnsafeFnPointer => {
this.emit_enum_variant("AdjustUnsafeFnPointer", 2, 0, |_| {
Ok(())
})
}
- ty::AdjustDerefRef(ref auto_deref_ref) => {
+ adjustment::AdjustDerefRef(ref auto_deref_ref) => {
this.emit_enum_variant("AdjustDerefRef", 3, 2, |this| {
this.emit_enum_variant_arg(0,
|this| Ok(this.emit_auto_deref_ref(ecx, auto_deref_ref)))
}
fn emit_autoref<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
- autoref: &ty::AutoRef<'tcx>) {
+ autoref: &adjustment::AutoRef<'tcx>) {
use serialize::Encoder;
self.emit_enum("AutoRef", |this| {
match autoref {
- &ty::AutoPtr(r, m) => {
+ &adjustment::AutoPtr(r, m) => {
this.emit_enum_variant("AutoPtr", 0, 2, |this| {
this.emit_enum_variant_arg(0,
|this| Ok(this.emit_region(ecx, *r)));
this.emit_enum_variant_arg(1, |this| m.encode(this))
})
}
- &ty::AutoUnsafe(m) => {
+ &adjustment::AutoUnsafe(m) => {
this.emit_enum_variant("AutoUnsafe", 1, 1, |this| {
this.emit_enum_variant_arg(0, |this| m.encode(this))
})
}
fn emit_auto_deref_ref<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
- auto_deref_ref: &ty::AutoDerefRef<'tcx>) {
+ auto_deref_ref: &adjustment::AutoDerefRef<'tcx>) {
use serialize::Encoder;
self.emit_struct("AutoDerefRef", 2, |this| {
if let Some(adjustment) = tcx.tables.borrow().adjustments.get(&id) {
match *adjustment {
- ty::AdjustDerefRef(ref adj) => {
+ adjustment::AdjustDerefRef(ref adj) => {
for autoderef in 0..adj.autoderefs {
let method_call = ty::MethodCall::autoderef(id, autoderef as u32);
if let Some(method) = tcx.tables.borrow().method_map.get(&method_call) {
fn read_upvar_capture(&mut self, dcx: &DecodeContext)
-> ty::UpvarCapture;
fn read_auto_adjustment<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
- -> ty::AutoAdjustment<'tcx>;
+ -> adjustment::AutoAdjustment<'tcx>;
fn read_cast_kind<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> cast::CastKind;
fn read_closure_kind<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
fn read_closure_ty<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> ty::ClosureTy<'tcx>;
fn read_auto_deref_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
- -> ty::AutoDerefRef<'tcx>;
+ -> adjustment::AutoDerefRef<'tcx>;
fn read_autoref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
- -> ty::AutoRef<'tcx>;
+ -> adjustment::AutoRef<'tcx>;
fn convert_def_id(&mut self,
dcx: &DecodeContext,
source: DefIdSource,
}).unwrap()
}
fn read_auto_adjustment<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
- -> ty::AutoAdjustment<'tcx> {
+ -> adjustment::AutoAdjustment<'tcx> {
self.read_enum("AutoAdjustment", |this| {
let variants = ["AdjustReifyFnPointer", "AdjustUnsafeFnPointer", "AdjustDerefRef"];
this.read_enum_variant(&variants, |this, i| {
Ok(match i {
- 1 => ty::AdjustReifyFnPointer,
- 2 => ty::AdjustUnsafeFnPointer,
+ 1 => adjustment::AdjustReifyFnPointer,
+ 2 => adjustment::AdjustUnsafeFnPointer,
3 => {
- let auto_deref_ref: ty::AutoDerefRef =
+ let auto_deref_ref: adjustment::AutoDerefRef =
this.read_enum_variant_arg(0,
|this| Ok(this.read_auto_deref_ref(dcx))).unwrap();
- ty::AdjustDerefRef(auto_deref_ref)
+ adjustment::AdjustDerefRef(auto_deref_ref)
}
- _ => panic!("bad enum variant for ty::AutoAdjustment")
+ _ => panic!("bad enum variant for adjustment::AutoAdjustment")
})
})
}).unwrap()
}
fn read_auto_deref_ref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
- -> ty::AutoDerefRef<'tcx> {
+ -> adjustment::AutoDerefRef<'tcx> {
self.read_struct("AutoDerefRef", 2, |this| {
- Ok(ty::AutoDerefRef {
+ Ok(adjustment::AutoDerefRef {
autoderefs: this.read_struct_field("autoderefs", 0, |this| {
Decodable::decode(this)
}).unwrap(),
}
fn read_autoref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
- -> ty::AutoRef<'tcx> {
+ -> adjustment::AutoRef<'tcx> {
self.read_enum("AutoRef", |this| {
let variants = ["AutoPtr", "AutoUnsafe"];
this.read_enum_variant(&variants, |this, i| {
this.read_enum_variant_arg(0, |this| {
Ok(this.read_region(dcx))
}).unwrap();
- let m: ast::Mutability =
+ let m: hir::Mutability =
this.read_enum_variant_arg(1, |this| {
Decodable::decode(this)
}).unwrap();
- ty::AutoPtr(dcx.tcx.mk_region(r), m)
+ adjustment::AutoPtr(dcx.tcx.mk_region(r), m)
}
1 => {
- let m: ast::Mutability =
+ let m: hir::Mutability =
this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
- ty::AutoUnsafe(m)
+ adjustment::AutoUnsafe(m)
}
- _ => panic!("bad enum variant for ty::AutoRef")
+ _ => panic!("bad enum variant for adjustment::AutoRef")
})
})
}).unwrap()
dcx.tcx.tables.borrow_mut().method_map.insert(method_call, method);
}
c::tag_table_adjustments => {
- let adj: ty::AutoAdjustment = val_dsr.read_auto_adjustment(dcx);
+ let adj =
+ val_dsr.read_auto_adjustment(dcx);
dcx.tcx.tables.borrow_mut().adjustments.insert(id, adj);
}
c::tag_table_closure_tys => {
// Testing of astencode_gen
#[cfg(test)]
-fn encode_item_ast(rbml_w: &mut Encoder, item: &ast::Item) {
+fn encode_item_ast(rbml_w: &mut Encoder, item: &hir::Item) {
rbml_w.start_tag(c::tag_tree as usize);
(*item).encode(rbml_w);
rbml_w.end_tag();
}
#[cfg(test)]
-fn decode_item_ast(par_doc: rbml::Doc) -> ast::Item {
+fn decode_item_ast(par_doc: rbml::Doc) -> hir::Item {
let chi_doc = par_doc.get(c::tag_tree as usize);
let mut d = reader::Decoder::new(chi_doc);
Decodable::decode(&mut d).unwrap()
}
#[cfg(test)]
-fn roundtrip(in_item: Option<P<ast::Item>>) {
- let in_item = in_item.unwrap();
+fn roundtrip(in_item: P<hir::Item>) {
let mut wr = Cursor::new(Vec::new());
encode_item_ast(&mut Encoder::new(&mut wr), &*in_item);
let rbml_doc = rbml::Doc::new(wr.get_ref());
#[test]
fn test_basic() {
let cx = mk_ctxt();
- roundtrip(quote_item!(&cx,
+ roundtrip(lower_item("e_item!(&cx,
fn foo() {}
- ));
+ ).unwrap()));
}
#[test]
fn test_smalltalk() {
let cx = mk_ctxt();
- roundtrip(quote_item!(&cx,
+ roundtrip(lower_item("e_item!(&cx,
fn foo() -> isize { 3 + 4 } // first smalltalk program ever executed.
- ));
+ ).unwrap()));
}
#[test]
fn test_more() {
let cx = mk_ctxt();
- roundtrip(quote_item!(&cx,
+ roundtrip(lower_item("e_item!(&cx,
fn foo(x: usize, y: usize) -> usize {
let z = x + y;
return z;
}
- ));
+ ).unwrap()));
}
#[test]
return alist {eq_fn: eq_int, data: Vec::new()};
}
).unwrap();
- let item_in = InlinedItemRef::Item(&*item);
+ let hir_item = lower_item(&item);
+ let item_in = InlinedItemRef::Item(&hir_item);
let item_out = simplify_ast(item_in);
- let item_exp = InlinedItem::Item(quote_item!(&cx,
+ let item_exp = InlinedItem::Item(lower_item("e_item!(&cx,
fn new_int_alist<B>() -> alist<isize, B> {
return alist {eq_fn: eq_int, data: Vec::new()};
}
- ).unwrap());
+ ).unwrap()));
match (item_out, item_exp) {
(InlinedItem::Item(item_out), InlinedItem::Item(item_exp)) => {
assert!(pprust::item_to_string(&*item_out) ==
projects / rust.git / blobdiff