Difference tests for 'Item'

Can almost diff 'ast.rs' - macros and view paths are still wonky. Also revamped tests to be
type-class based. The instances for 'NonEmpty', '[]', and 'Maybe' are particularly helpful.

Progress made towards #16.

Author: harpocrates

sample-sources/expressions.rs

@@ -23,7 +23,7 @@ fn main() {
   loop { break; }
   'l: loop { break 'l 1; }
   match x { _ => () }
-//  let x = move |a,b,c| { a + b + c }; 
+  let x = move |a,b,c| { a + b + c }; 
   let x = { 1 };
   let x = unsafe { 1 };
   a = 1;
@@ -44,3 +44,9 @@ fn main() {
   return 0;
   return;
 }
+
+fn precedences() {
+  x==&y||z|w.0<=x**y*&&z^=l^m<<=n;
+  y|z..wm;
+  1>!x%y-z*-w||u?==v;
+}

sample-sources/items.rs

@@ -16,7 +16,11 @@ mod foo { }
 mod bar {
 
   extern { }
-  extern "C" { }
+  extern "C" {
+    fn foo(x: int) -> int;
+    static x: int;
+    static mut x: *mut int;
+  }
 
   type Foo = Bar<u8>;
 
@@ -26,14 +30,33 @@ mod bar {
   union Foo<A, B> { x: A, y: B }
 
   trait Foo { }
-  trait Foo<T> { }
+  trait Foo<T> {
+    const ID1: i32;
+    const ID2: i32 = 1;
+
+    fn area1(&self) -> f64;
+    fn area2(&self) -> f64 { 1f64 }
+
+    type N;
+    type N: fmt::Display;
+    type N: fmt::Display = i32;
+
+   // foo!{}
+  }
 
   impl Trait for .. {}
   impl Trait<T> for .. {}
-  impl<A> Foo<A> { }
+  impl<A> Foo<A> {
+    const ID: i32 = 1;
+    fn area(&self) -> f64 { 1f64 }
+    type N = i32;
+    // foo!()
+
+  }
   impl<A> Trait for Foo<A> { }
+  impl<A> !Trait for Foo<A> { }
 
-  macro_rules! foo { }
-  foo!();
+ // macro_rules! foo { }
+ // foo!();
 
 }

sample-sources/literals.rs

@@ -20,7 +20,7 @@ fn main() {
   "hello world";
   r"hello world";
   r#"hello " world"#;
-//  b"hello world";
+  b"hello world";
   br"hello world";
   br#"hello " world"#;
 

sample-sources/types.rs

@@ -25,4 +25,11 @@ fn main() {
 
 fn foo() -> impl Bound1 + Bound2 + Bound3 { }
 
-
+pub fn walk<F: 'a + 'static>(x: i32, it: &mut F) -> bool
+where
+  F: FnMut(&Pat) -> bool,
+  'a: 'b + 'c,
+  F = i32,
+{
+  foo::<'a,A,B,C=i32> 
+}