---

yaml
---
r: 212881
b: refs/heads/master
c: abe5f7b
h: refs/heads/master
i:
  212879: dc75ae5
v: v3

Author: nrc

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b26eeffacb80c122e0559ada5584fdce7183561b
+refs/heads/master: abe5f7b95a1d856b69eb68344426e29d30918aea
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/src/librustc_trans/save/dump_csv.rs

@@ -437,30 +437,20 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
 
     fn process_struct_field_def(&mut self,
                                 field: &ast::StructField,
-                                qualname: &str,
-                                scope_id: NodeId) {
-        match field.node.kind {
-            ast::NamedField(ident, _) => {
-                let name = get_ident(ident);
-                let qualname = format!("{}::{}", qualname, name);
-                let typ =
-                    ppaux::ty_to_string(
-                        &self.analysis.ty_cx,
-                        *self.analysis.ty_cx.node_types().get(&field.node.id).unwrap());
-                match self.span.sub_span_before_token(field.span, token::Colon) {
-                    Some(sub_span) => self.fmt.field_str(field.span,
-                                                         Some(sub_span),
-                                                         field.node.id,
-                                                         &name,
-                                                         &qualname,
-                                                         &typ,
-                                                         scope_id),
-                    None => self.sess.span_bug(field.span,
-                                               &format!("Could not find sub-span for field {}",
-                                                       qualname)),
-                }
-            },
-            _ => (),
+                                parent_id: NodeId) {
+        let field_data = self.save_ctxt.get_field_data(field, parent_id);
+        if let Some(field_data) = field_data {
+            if let super::Data::VariableData(field_data) = field_data {
+                self.fmt.field_str(field.span,
+                                   Some(field_data.span),
+                                   field_data.id,
+                                   &field_data.name,
+                                   &field_data.qualname,
+                                   &field_data.type_value,
+                                   field_data.scope);
+            } else {
+                self.sess.span_bug(field.span, "expected VariableData");
+            }
         }
     }
 
@@ -593,8 +583,8 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
 
         // fields
         for field in &def.fields {
-            self.process_struct_field_def(field, &qualname, item.id);
-            self.visit_ty(&*field.node.ty);
+            self.process_struct_field_def(field, item.id);
+            self.visit_ty(&field.node.ty);
         }
 
         self.process_generic_params(ty_params, item.span, &qualname, item.id);
@@ -648,7 +638,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
                                                     item.id);
 
                         for field in &struct_def.fields {
-                            self.process_struct_field_def(field, &qualname, variant.node.id);
+                            self.process_struct_field_def(field, variant.node.id);
                             self.visit_ty(&*field.node.ty);
                         }
                     }

trunk/src/librustc_trans/save/mod.rs

@@ -23,9 +23,11 @@ use syntax::parse::token::{self, get_ident, keywords};
 use syntax::visit::{self, Visitor};
 use syntax::print::pprust::ty_to_string;
 
+use util::ppaux;
 
 use self::span_utils::SpanUtils;
 
+
 mod span_utils;
 mod recorder;
 
@@ -47,7 +49,7 @@ pub struct CrateData {
 pub enum Data {
     /// Data for all kinds of functions and methods.
     FunctionData(FunctionData),
-    /// Data for local and global variables (consts and statics).
+    /// Data for local and global variables (consts and statics), and fields.
     VariableData(VariableData),
     /// Data for modules.
     ModData(ModData),
@@ -218,6 +220,33 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
         }
     }
 
+    // FIXME: we ought to be able to get the parent id ourselves, but we can't
+    // for now.
+    pub fn get_field_data(&self, field: &ast::StructField, parent: NodeId) -> Option<Data> {
+        match field.node.kind {
+            ast::NamedField(ident, _) => {
+                let name = get_ident(ident);
+                let qualname = format!("::{}::{}",
+                                       self.analysis.ty_cx.map.path_to_string(parent),
+                                       name);
+                let typ = ppaux::ty_to_string(&self.analysis.ty_cx,
+                                              *self.analysis.ty_cx.node_types()
+                                                  .get(&field.node.id).unwrap());
+                let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon);
+                Some(Data::VariableData(VariableData {
+                    id: field.node.id,
+                    name: get_ident(ident).to_string(),
+                    qualname: qualname,
+                    span: sub_span.unwrap(),
+                    scope: parent,
+                    value: "".to_owned(),
+                    type_value: typ,
+                }))
+            },
+            _ => None,
+        }
+    }
+
     pub fn get_expr_data(&self, expr: &ast::Expr) -> Data {
         match expr.node {
             ast::ExprField(ref sub_ex, ident) => {

trunk/src/rustllvm/ExecutionEngineWrapper.cpp

@@ -16,8 +16,8 @@ using namespace llvm;
 using namespace llvm::sys;
 using namespace llvm::object;
 
-// libmorestack is not used on other platforms
-#if defined(__linux__) || defined(__APPLE__)
+// libmorestack is not used on Windows
+#if !defined(_WIN32) && !defined(__FreeBSD__) && !defined(__DragonFly__) && !defined(__Bitrig__)
 extern "C" void __morestack(void);
 
 static void* morestack_addr() {
@@ -35,7 +35,7 @@ class RustJITMemoryManager : public SectionMemoryManager
 
     uint64_t getSymbolAddress(const std::string &Name) override
     {
-#if defined(__linux__) || defined(__APPLE__)
+#if !defined(_WIN32) && !defined(__FreeBSD__) && !defined(__DragonFly__) && !defined(__Bitrig__)
         if (Name == "__morestack" || Name == "___morestack")
             return reinterpret_cast<uint64_t>(__morestack);
         if (Name == "__morestack_addr" || Name == "___morestack_addr")

trunk/src/test/auxiliary/extern_calling_convention.rs

@@ -14,10 +14,10 @@
 #[inline(never)]
 #[cfg(target_arch = "x86_64")]
 pub extern "win64" fn foo(a: isize, b: isize, c: isize, d: isize) {
-    assert_eq!(a, 1);
-    assert_eq!(b, 2);
-    assert_eq!(c, 3);
-    assert_eq!(d, 4);
+    assert!(a == 1);
+    assert!(b == 2);
+    assert!(c == 3);
+    assert!(d == 4);
 
     println!("a: {}, b: {}, c: {}, d: {}",
              a, b, c, d)
@@ -26,10 +26,10 @@ pub extern "win64" fn foo(a: isize, b: isize, c: isize, d: isize) {
 #[inline(never)]
 #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "aarch64"))]
 pub extern fn foo(a: isize, b: isize, c: isize, d: isize) {
-    assert_eq!(a, 1);
-    assert_eq!(b, 2);
-    assert_eq!(c, 3);
-    assert_eq!(d, 4);
+    assert!(a == 1);
+    assert!(b == 2);
+    assert!(c == 3);
+    assert!(d == 4);
 
     println!("a: {}, b: {}, c: {}, d: {}",
              a, b, c, d)

trunk/src/test/bench/shootout-mandelbrot.rs

@@ -54,7 +54,7 @@ const LIMIT: f64 = 2.0;
 const WORKERS: usize = 16;
 
 fn mandelbrot<W: Write>(w: usize, mut out: W) -> io::Result<()> {
-    assert_eq!(WORKERS % 2, 0);
+    assert!(WORKERS % 2 == 0);
 
     // Ensure w and h are multiples of 8.
     let w = (w + 7) / 8 * 8;
@@ -76,7 +76,7 @@ fn mandelbrot<W: Write>(w: usize, mut out: W) -> io::Result<()> {
     let v_consts = f64x2(1.5, 1.0);
 
     // A lot of this code assumes this (so do other lang benchmarks)
-    assert_eq!(w, h);
+    assert!(w == h);
     let mut precalc_r = Vec::with_capacity(w);
     let mut precalc_i = Vec::with_capacity(h);
 

trunk/src/test/compile-fail/builtin-superkinds-self-type.rs

@@ -23,5 +23,5 @@ impl <T: Sync> Foo for T { }
 fn main() {
     let (tx, rx) = channel();
     1193182.foo(tx);
-    assert_eq!(rx.recv(), 1193182);
+    assert!(rx.recv() == 1193182);
 }

trunk/src/test/compile-fail/match-static-const-lc.rs

@@ -22,7 +22,7 @@ fn f() {
         //~^ ERROR constant in pattern `a` should have an upper case name such as `A`
         (x, y) => 1 + x + y,
     };
-    assert_eq!(r, 1);
+    assert!(r == 1);
 }
 
 mod m {
@@ -37,7 +37,7 @@ fn g() {
         //~^ ERROR constant in pattern `aha` should have an upper case name such as `AHA`
         (x, y)   => 1 + x + y,
     };
-    assert_eq!(r, 1);
+    assert!(r == 1);
 }
 
 mod n {
@@ -51,7 +51,7 @@ fn h() {
 //~^ ERROR constant in pattern `not_okay` should have an upper case name such as `NOT_OKAY`
         (x, y)   => 1 + x + y,
     };
-    assert_eq!(r, 1);
+    assert!(r == 1);
 }
 
 fn main () {

trunk/src/test/compile-fail/mod_file_correct_spans.rs

@@ -13,5 +13,5 @@
 mod mod_file_aux;
 
 fn main() {
-    assert_eq!(mod_file_aux::bar(), 10); //~ ERROR unresolved name
+    assert!(mod_file_aux::bar() == 10); //~ ERROR unresolved name
 }

trunk/src/test/compile-fail/private-struct-field-cross-crate.rs

@@ -14,6 +14,6 @@ use cci_class::kitties::cat;
 
 fn main() {
   let nyan : cat = cat(52, 99);
-  assert_eq!(nyan.meows, 52);
+  assert!((nyan.meows == 52));
   //~^ ERROR field `meows` of struct `cci_class::kitties::cat` is private
 }

trunk/src/test/compile-fail/private-struct-field.rs

@@ -20,5 +20,5 @@ mod cat {
 
 fn main() {
     let nyan = cat::new_cat();
-    assert_eq!(nyan.meows, 52);    //~ ERROR field `meows` of struct `cat::Cat` is private
+    assert!(nyan.meows == 52);    //~ ERROR field `meows` of struct `cat::Cat` is private
 }

trunk/src/test/compile-fail/syntax-extension-minor.rs

@@ -17,5 +17,6 @@ pub fn main() {
     assert_eq!(concat_idents!(asd, f_f, dsa), "<.<".to_string());
     //~^ ERROR: unresolved name `asdf_fdsa`
 
-    assert_eq!(stringify!(use_mention_distinction), "use_mention_distinction");
+    assert!(stringify!(use_mention_distinction) ==
+                "use_mention_distinction");
 }

trunk/src/test/parse-fail/macros-no-semicolon.rs

@@ -11,7 +11,7 @@
 // compile-flags: -Z parse-only
 
 fn main() {
-    assert_eq!(1, 2)
-    assert_eq!(3, 4) //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `assert_eq`
+    assert!(1 == 2)
+    assert!(3 == 4) //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `assert`
     println!("hello");
 }

trunk/src/test/pretty/do1.rs

@@ -12,4 +12,4 @@
 
 fn f<F>(f: F) where F: Fn(isize) { f(10) }
 
-fn main() { f(|i| { assert_eq!(i , 10) }) }
+fn main() { f(|i| { assert!(i == 10) }) }

trunk/src/test/run-fail/panic.rs

@@ -9,4 +9,4 @@
 // except according to those terms.
 
 // error-pattern:1 == 2
-fn main() { assert!(1 == 2); }
+fn main() { assert!((1 == 2)); }

trunk/src/test/run-make/extern-flag-disambiguates/d.rs

@@ -16,6 +16,6 @@ extern crate c;
 fn t(a: &'static usize) -> usize { a as *const _ as usize }
 
 fn main() {
-    assert_eq!(t(a::token()), t(b::a_token()));
+    assert!(t(a::token()) == t(b::a_token()));
     assert!(t(a::token()) != t(c::a_token()));
 }

trunk/src/test/run-make/static-unwinding/main.rs

@@ -28,7 +28,7 @@ fn main() {
     }).join().err().unwrap();
 
     unsafe {
-        assert_eq!(lib::statik, 1);
-        assert_eq!(statik, 1);
+        assert!(lib::statik == 1);
+        assert!(statik == 1);
     }
 }

trunk/src/test/run-pass-fulldeps/compiler-calls.rs

@@ -78,5 +78,5 @@ fn main() {
     // we should never get use this filename, but lets make sure they are valid args.
     let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()];
     rustc_driver::run_compiler(&args, &mut tc);
-    assert_eq!(tc.count, 30);
+    assert!(tc.count == 30);
 }

trunk/src/test/run-pass-valgrind/dst-dtor-2.rs

@@ -27,6 +27,6 @@ pub fn main() {
         let _x: Box<Fat<[Foo]>> = Box::<Fat<[Foo; 3]>>::new(Fat { f: [Foo, Foo, Foo] });
     }
     unsafe {
-        assert_eq!(DROP_RAN, 3);
+        assert!(DROP_RAN == 3);
     }
 }

trunk/src/test/run-pass/arith-2.rs

@@ -13,6 +13,6 @@
 
 pub fn main() {
     let i32_c: isize = 0x10101010;
-    assert_eq!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3),
+    assert!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
                  i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3));
 }

trunk/src/test/run-pass/artificial-block.rs

@@ -11,4 +11,4 @@
 
 fn f() -> isize { { return 3; } }
 
-pub fn main() { assert_eq!(f(), 3); }
+pub fn main() { assert!((f() == 3)); }

trunk/src/test/run-pass/assignability-trait.rs

@@ -43,7 +43,7 @@ fn length<A, T: iterable<A>>(x: T) -> usize {
 pub fn main() {
     let x: Vec<isize> = vec!(0,1,2,3);
     // Call a method
-    x.iterate(|y| { assert_eq!(x[*y as usize], *y); true });
+    x.iterate(|y| { assert!(x[*y as usize] == *y); true });
     // Call a parameterized function
     assert_eq!(length(x.clone()), x.len());
     // Call a parameterized function, with type arguments that require

trunk/src/test/run-pass/associated-types-return.rs

@@ -16,7 +16,7 @@ pub trait Foo {
     fn boo(&self) -> <Self as Foo>::A;
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq)]
 pub struct Bar;
 
 impl Foo for isize {
@@ -44,12 +44,12 @@ fn foo2<I: Foo>(x: I) -> <I as Foo>::A {
 
 pub fn main() {
     let a = 42;
-    assert_eq!(foo2(a), 42);
+    assert!(foo2(a) == 42);
 
     let a = Bar;
-    assert_eq!(foo2(a), 43);
+    assert!(foo2(a) == 43);
 
     let a = 'a';
     foo1(a);
-    assert_eq!(foo2(a), Bar);
+    assert!(foo2(a) == Bar);
 }

trunk/src/test/run-pass/bool.rs

@@ -74,8 +74,8 @@ fn main() {
     assert!(true >= false);
     assert!(!(true <= false));
 
-    assert_eq!(true.cmp(&true), Equal);
-    assert_eq!(false.cmp(&false), Equal);
-    assert_eq!(true.cmp(&false), Greater);
-    assert_eq!(false.cmp(&true), Less);
+    assert!(true.cmp(&true) == Equal);
+    assert!(false.cmp(&false) == Equal);
+    assert!(true.cmp(&false) == Greater);
+    assert!(false.cmp(&true) == Less);
 }

trunk/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs

@@ -30,5 +30,5 @@ fn foo<T: Foo + 'static>(val: T, chan: Sender<T>) {
 pub fn main() {
     let (tx, rx) = channel();
     foo(31337, tx);
-    assert_eq!(rx.recv().unwrap(), 31337);
+    assert!(rx.recv().unwrap() == 31337);
 }

trunk/src/test/run-pass/builtin-superkinds-capabilities-xc.rs

@@ -20,7 +20,7 @@ extern crate trait_superkinds_in_metadata;
 use std::sync::mpsc::{channel, Sender, Receiver};
 use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare};
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq)]
 struct X<T>(T);
 
 impl <T: Sync> RequiresShare for X<T> { }
@@ -33,5 +33,5 @@ fn foo<T: RequiresRequiresShareAndSend + 'static>(val: T, chan: Sender<T>) {
 pub fn main() {
     let (tx, rx): (Sender<X<isize>>, Receiver<X<isize>>) = channel();
     foo(X(31337), tx);
-    assert_eq!(rx.recv().unwrap(), X(31337));
+    assert!(rx.recv().unwrap() == X(31337));
 }