auto merge of #5320 : apasel422/rust/metaderive, r=graydon

This is the first in a series of patches I'm working on to clean up the code related to `deriving`. This patch allows

```
#[deriving_eq]
#[deriving_iter_bytes]
#[deriving_clone]
struct Foo { bar: uint }
```
to be replaced with:
```
#[deriving(Eq, IterBytes, Clone)]
struct Foo { bar: uint }
```
It leaves the old attributes alone for the time being.

Eventually I'd like to incorporate the new closest-match-suggestion infrastructure for mistyped trait names, and also pass the sub-attributes to the deriving code, so that the following will be possible:
```
#[deriving(TotalOrd(qux, bar))]
struct Foo { bar: uint, baz: char, qux: int }
```
This says to derive an `impl` in which the objects' `qux` fields are compared first, followed by `bar`, while `baz` is ignored in the comparison. If no fields are specified explicitly, all fields will be compared in the order they're defined in the `struct`. This might also be useful for `Eq`. Coming soon.

Author: bors

src/libsyntax/ext/base.rs

@@ -148,6 +148,9 @@ pub fn syntax_expander_table() -> SyntaxEnv {
     syntax_expanders.insert(@~"log_syntax",
                             builtin_normal_tt(
                                 ext::log_syntax::expand_syntax_ext));
+    syntax_expanders.insert(@~"deriving",
+                            @SE(ItemDecorator(
+                                ext::deriving::expand_meta_deriving)));
     syntax_expanders.insert(@~"deriving_eq",
                             @SE(ItemDecorator(
                                 ext::deriving::expand_deriving_eq)));

src/libsyntax/ext/deriving.rs

@@ -56,6 +56,48 @@ type ExpandDerivingEnumDefFn = &self/fn(ext_ctxt,
                                         ident,
                                         y: &Generics) -> @item;
 
+pub fn expand_meta_deriving(cx: ext_ctxt,
+                            _span: span,
+                            mitem: @meta_item,
+                            in_items: ~[@item])
+                         -> ~[@item] {
+    use ast::{meta_list, meta_name_value, meta_word};
+
+    match mitem.node {
+        meta_name_value(_, l) => {
+            cx.span_err(l.span, ~"unexpected value in `deriving`");
+            in_items
+        }
+        meta_word(_) | meta_list(_, []) => {
+            cx.span_warn(mitem.span, ~"empty trait list in `deriving`");
+            in_items
+        }
+        meta_list(_, titems) => {
+            do titems.foldr(in_items) |&titem, in_items| {
+                match titem.node {
+                    meta_name_value(tname, _) |
+                    meta_list(tname, _) |
+                    meta_word(tname) => {
+                        match *tname {
+                            ~"Clone" => expand_deriving_clone(cx,
+                                titem.span, titem, in_items),
+                            ~"Eq" => expand_deriving_eq(cx, titem.span,
+                                titem, in_items),
+                            ~"IterBytes" => expand_deriving_iter_bytes(cx,
+                                titem.span, titem, in_items),
+                            tname => {
+                                cx.span_err(titem.span, fmt!("unknown \
+                                    `deriving` trait: `%s`", tname));
+                                in_items
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 pub fn expand_deriving_eq(cx: ext_ctxt,
                           span: span,
                           _mitem: @meta_item,

src/test/compile-fail/deriving-meta-unknown-trait.rs

@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Eqr)] //~ ERROR unknown `deriving` trait: `Eqr`
+struct Foo;
+
+pub fn main() {}

src/test/run-pass/deriving-meta-empty-trait-list.rs

@@ -0,0 +1,19 @@
+// xfail-pretty
+
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving]   //~ WARNING empty trait list in `deriving`
+struct Foo;
+
+#[deriving()] //~ WARNING empty trait list in `deriving`
+struct Bar;
+
+pub fn main() {}

src/test/run-pass/deriving-meta-multiple.rs

@@ -0,0 +1,29 @@
+// xfail-fast
+
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Eq)]
+#[deriving(Clone)]
+#[deriving(IterBytes)]
+struct Foo {
+    bar: uint,
+    baz: int
+}
+
+pub fn main() {
+    use core::hash::{Hash, HashUtil}; // necessary for IterBytes check
+
+    let a = Foo {bar: 4, baz: -3};
+
+    a == a;    // check for Eq impl w/o testing its correctness
+    a.clone(); // check for Clone impl w/o testing its correctness
+    a.hash();  // check for IterBytes impl w/o testing its correctness
+}

src/test/run-pass/deriving-meta.rs

@@ -0,0 +1,27 @@
+// xfail-fast
+
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Eq, Clone, IterBytes)]
+struct Foo {
+    bar: uint,
+    baz: int
+}
+
+pub fn main() {
+    use core::hash::{Hash, HashUtil}; // necessary for IterBytes check
+
+    let a = Foo {bar: 4, baz: -3};
+
+    a == a;    // check for Eq impl w/o testing its correctness
+    a.clone(); // check for Clone impl w/o testing its correctness
+    a.hash();  // check for IterBytes impl w/o testing its correctness
+}