From 24efea720860e1dc8d4d1035f1ea8d56a3498614 Mon Sep 17 00:00:00 2001 From: Andrew Paseltiner Date: Mon, 11 Mar 2013 16:47:23 -0400 Subject: [PATCH] syntax: implement #[deriving] meta-attribute --- src/libsyntax/ext/base.rs | 3 ++ src/libsyntax/ext/deriving.rs | 42 +++++++++++++++++++ .../deriving-meta-unknown-trait.rs | 14 +++++++ .../deriving-meta-empty-trait-list.rs | 19 +++++++++ src/test/run-pass/deriving-meta-multiple.rs | 29 +++++++++++++ src/test/run-pass/deriving-meta.rs | 27 ++++++++++++ 6 files changed, 134 insertions(+) create mode 100644 src/test/compile-fail/deriving-meta-unknown-trait.rs create mode 100644 src/test/run-pass/deriving-meta-empty-trait-list.rs create mode 100644 src/test/run-pass/deriving-meta-multiple.rs create mode 100644 src/test/run-pass/deriving-meta.rs diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 23cabc09946..1edaebefedb 100644 --- a/src/libsyntax/ext/base.rs +++ b/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))); diff --git a/src/libsyntax/ext/deriving.rs b/src/libsyntax/ext/deriving.rs index efea962a089..093327ec32e 100644 --- a/src/libsyntax/ext/deriving.rs +++ b/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, diff --git a/src/test/compile-fail/deriving-meta-unknown-trait.rs b/src/test/compile-fail/deriving-meta-unknown-trait.rs new file mode 100644 index 00000000000..0b9f61dac9e --- /dev/null +++ b/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 or the MIT license +// , 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() {} diff --git a/src/test/run-pass/deriving-meta-empty-trait-list.rs b/src/test/run-pass/deriving-meta-empty-trait-list.rs new file mode 100644 index 00000000000..8e7afffaf0d --- /dev/null +++ b/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 or the MIT license +// , 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() {} diff --git a/src/test/run-pass/deriving-meta-multiple.rs b/src/test/run-pass/deriving-meta-multiple.rs new file mode 100644 index 00000000000..d94b6fcb415 --- /dev/null +++ b/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 or the MIT license +// , 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 +} diff --git a/src/test/run-pass/deriving-meta.rs b/src/test/run-pass/deriving-meta.rs new file mode 100644 index 00000000000..efb202028f3 --- /dev/null +++ b/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 or the MIT license +// , 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 +}