rustc_metadata: remove astencode tests.

4 files changed, 12 insertions, 187 deletions

diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 80e034721d6..f7c3eebdc29 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -81,21 +81,7 @@ pub trait Resolver {
 
     // We must keep the set of definitions up to date as we add nodes that weren't in the AST.
     // This should only return `None` during testing.
-    fn definitions(&mut self) -> Option<&mut Definitions>;
-}
-
-pub struct DummyResolver;
-impl Resolver for DummyResolver {
-    fn resolve_generated_global_path(&mut self, _path: &hir::Path, _is_value: bool) -> Def {
-        Def::Err
-    }
-    fn get_resolution(&mut self, _id: NodeId) -> Option<PathResolution> {
-        None
-    }
-    fn record_resolution(&mut self, _id: NodeId, _def: Def) {}
-    fn definitions(&mut self) -> Option<&mut Definitions> {
-        None
-    }
+    fn definitions(&mut self) -> &mut Definitions;
 }
 
 pub fn lower_crate(sess: &Session,
@@ -177,9 +163,9 @@ impl<'a> LoweringContext<'a> {
         where F: FnOnce(&mut LoweringContext) -> T
     {
         let old_def = self.parent_def;
-        self.parent_def = match self.resolver.definitions() {
-            Some(defs) => Some(defs.opt_def_index(parent_id).unwrap()),
-            None => old_def,
+        self.parent_def = {
+            let defs = self.resolver.definitions();
+            Some(defs.opt_def_index(parent_id).unwrap())
         };
 
         let result = f(self);
@@ -1719,9 +1705,10 @@ impl<'a> LoweringContext<'a> {
         let expr_path = hir::ExprPath(None, self.path_ident(span, id));
         let expr = self.expr(span, expr_path, ThinVec::new());
 
-        let def = self.resolver.definitions().map(|defs| {
+        let def = {
+            let defs = self.resolver.definitions();
             Def::Local(defs.local_def_id(binding), binding)
-        }).unwrap_or(Def::Err);
+        };
         self.resolver.record_resolution(expr.id, def);
 
         expr
@@ -1869,11 +1856,12 @@ impl<'a> LoweringContext<'a> {
         let pat = self.pat(span, pat_ident);
 
         let parent_def = self.parent_def;
-        let def = self.resolver.definitions().map(|defs| {
+        let def = {
+            let defs = self.resolver.definitions();
             let def_path_data = DefPathData::Binding(name.as_str());
             let def_index = defs.create_def_with_parent(parent_def, pat.id, def_path_data);
             Def::Local(DefId::local(def_index), pat.id)
-        }).unwrap_or(Def::Err);
+        };
         self.resolver.record_resolution(pat.id, def);
 
         pat
diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs
index ece4e8b1097..b7781ef620f 100644
--- a/src/librustc_metadata/astencode.rs
+++ b/src/librustc_metadata/astencode.rs
@@ -51,11 +51,6 @@ use rbml;
 use rustc_serialize::{Decodable, Decoder, DecoderHelpers};
 use rustc_serialize::{Encodable, EncoderHelpers};
 
-#[cfg(test)] use std::io::Cursor;
-#[cfg(test)] use syntax::parse;
-#[cfg(test)] use rustc::hir::print as pprust;
-#[cfg(test)] use rustc::hir::lowering::{LoweringContext, DummyResolver};
-
 struct DecodeContext<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     cdata: &'a cstore::CrateMetadata,
@@ -1068,136 +1063,3 @@ fn inlined_item_id_range(ii: &InlinedItem) -> IdRange {
     ii.visit(&mut visitor);
     visitor.result()
 }
-
-// ______________________________________________________________________
-// Testing of astencode_gen
-
-#[cfg(test)]
-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(item_doc: rbml::Doc) -> hir::Item {
-    let chi_doc = item_doc.get(c::tag_tree as usize);
-    let mut d = reader::Decoder::new(chi_doc);
-    Decodable::decode(&mut d).unwrap()
-}
-
-#[cfg(test)]
-trait FakeExtCtxt {
-    fn call_site(&self) -> syntax_pos::Span;
-    fn cfg(&self) -> ast::CrateConfig;
-    fn ident_of(&self, st: &str) -> ast::Ident;
-    fn name_of(&self, st: &str) -> ast::Name;
-    fn parse_sess(&self) -> &parse::ParseSess;
-}
-
-#[cfg(test)]
-impl FakeExtCtxt for parse::ParseSess {
-    fn call_site(&self) -> syntax_pos::Span {
-        syntax_pos::Span {
-            lo: syntax_pos::BytePos(0),
-            hi: syntax_pos::BytePos(0),
-            expn_id: syntax_pos::NO_EXPANSION,
-        }
-    }
-    fn cfg(&self) -> ast::CrateConfig { Vec::new() }
-    fn ident_of(&self, st: &str) -> ast::Ident {
-        parse::token::str_to_ident(st)
-    }
-    fn name_of(&self, st: &str) -> ast::Name {
-        parse::token::intern(st)
-    }
-    fn parse_sess(&self) -> &parse::ParseSess { self }
-}
-
-#[cfg(test)]
-fn mk_ctxt() -> parse::ParseSess {
-    parse::ParseSess::new()
-}
-
-#[cfg(test)]
-fn with_testing_context<T, F: FnOnce(&mut LoweringContext) -> T>(f: F) -> T {
-    let mut resolver = DummyResolver;
-    let mut lcx = LoweringContext::testing_context(&mut resolver);
-    f(&mut lcx)
-}
-
-#[cfg(test)]
-fn roundtrip(in_item: 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());
-    let out_item = decode_item_ast(rbml_doc);
-
-    assert!(in_item == out_item);
-}
-
-#[test]
-fn test_basic() {
-    let cx = mk_ctxt();
-    with_testing_context(|lcx| {
-        roundtrip(lcx.lower_item(&quote_item!(&cx,
-            fn foo() {}
-        ).unwrap()));
-    });
-}
-
-#[test]
-fn test_smalltalk() {
-    let cx = mk_ctxt();
-    with_testing_context(|lcx| {
-        roundtrip(lcx.lower_item(&quote_item!(&cx,
-            fn foo() -> isize { 3 + 4 } // first smalltalk program ever executed.
-        ).unwrap()));
-    });
-}
-
-#[test]
-fn test_more() {
-    let cx = mk_ctxt();
-    with_testing_context(|lcx| {
-        roundtrip(lcx.lower_item(&quote_item!(&cx,
-            fn foo(x: usize, y: usize) -> usize {
-                let z = x + y;
-                return z;
-            }
-        ).unwrap()));
-    });
-}
-
-#[test]
-fn test_simplification() {
-    use middle::cstore::LOCAL_CRATE;
-    use rustc::hir::def_id::CRATE_DEF_INDEX;
-
-    let cx = mk_ctxt();
-    let item = quote_item!(&cx,
-        fn new_int_alist<B>() -> alist<isize, B> {
-            fn eq_int(a: isize, b: isize) -> bool { a == b }
-            return alist {eq_fn: eq_int, data: Vec::new()};
-        }
-    ).unwrap();
-    let cx = mk_ctxt();
-    with_testing_context(|lcx| {
-        let hir_item = lcx.lower_item(&item);
-        let def_id = DefId { krate: LOCAL_CRATE, index: CRATE_DEF_INDEX }; // dummy
-        let item_in = InlinedItemRef::Item(def_id, &hir_item);
-        let (item_out, _) = simplify_ast(item_in);
-        let item_exp = InlinedItem::Item(def_id, P(lcx.lower_item(&quote_item!(&cx,
-            fn new_int_alist<B>() -> alist<isize, B> {
-                return alist {eq_fn: eq_int, data: Vec::new()};
-            }
-        ).unwrap())));
-        match (item_out, item_exp) {
-            (InlinedItem::Item(_, item_out), InlinedItem::Item(_, item_exp)) => {
-                 assert!(pprust::item_to_string(&item_out) ==
-                         pprust::item_to_string(&item_exp));
-            }
-            _ => bug!()
-        }
-    });
-}
diff --git a/src/librustc_metadata/rbml/writer.rs b/src/librustc_metadata/rbml/writer.rs
index d6f4b0d03f2..17b3c392edb 100644
--- a/src/librustc_metadata/rbml/writer.rs
+++ b/src/librustc_metadata/rbml/writer.rs
@@ -495,28 +495,3 @@ impl<'a> serialize::Encoder for Encoder<'a> {
         self.end_tag()
     }
 }
-
-#[test]
-fn test_option_int() {
-    use rbml::reader;
-    use serialize::{Encodable, Decodable};
-    use std::io::Cursor;
-
-    fn test_v(v: Option<isize>) {
-        debug!("v == {:?}", v);
-        let mut wr = Cursor::new(Vec::new());
-        {
-            let mut rbml_w = Encoder::new(&mut wr);
-            let _ = v.encode(&mut rbml_w);
-        }
-        let rbml_doc = reader::Doc::new(wr.get_ref());
-        let mut deser = reader::Decoder::new(rbml_doc);
-        let v1 = Decodable::decode(&mut deser).unwrap();
-        debug!("v1 == {:?}", v1);
-        assert_eq!(v, v1);
-    }
-
-    test_v(Some(22));
-    test_v(None);
-    test_v(Some(3));
-}
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 912b39cafff..31893b0873c 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -1151,8 +1151,8 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
         self.def_map.insert(id, PathResolution::new(def));
     }
 
-    fn definitions(&mut self) -> Option<&mut Definitions> {
-        Some(&mut self.definitions)
+    fn definitions(&mut self) -> &mut Definitions {
+        &mut self.definitions
     }
 }