syntax: Shrink the impl PartialOrd with #[derive(Ord)]

This PR generates a simplified `PartialOrd` implementation when the
type is `Ord` and non-generic. It produces essentially:

impl ::std::cmp::PartialOrd for $ty {
    fn partial_cmp(&self, other: &$ty) -> Option<std::cmp::Ordering> {
        Some(::std::cmp::Ord::cmp(self, other))
    }
}

Author: erickt

src/libsyntax/ext/deriving/cmp/ord.rs

@@ -8,14 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use abi;
 use ast;
 use ast::{MetaItem, Item, Expr};
-use codemap::Span;
+use codemap::{Span, respan};
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
 use ext::deriving::generic::ty::*;
-use parse::token::InternedString;
+use owned_slice::OwnedSlice;
+use parse::token::{InternedString, special_idents};
 use ptr::P;
 
 use super::partial_ord;
@@ -52,7 +54,7 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt,
 
     trait_def.expand(cx, mitem, item, push);
 
-    partial_ord::expand_deriving_partial_ord(cx, span, mitem, item, push)
+    expand_deriving_partial_ord_when_ord(cx, span, mitem, item, push)
 }
 
 
@@ -143,3 +145,148 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
         }),
         cx, span, substr)
 }
+
+fn expand_deriving_partial_ord_when_ord(cx: &mut ExtCtxt,
+                                        span: Span,
+                                        mitem: &MetaItem,
+                                        item: &Item,
+                                        push: &mut FnMut(P<Item>)) {
+    // For generic types we need to destructure our value in order to recursively call clone.
+    // However, as an optimization for non-generic types, we can just generate:
+    //
+    // impl<...> PartialOrd for $ty {
+    //     fn partial_cmp(&self, other: &$ty) -> Self { self.cmp(other) }
+    // }
+    //
+    // But the generic deriving helpers do not support generating such a simple method. So we'll
+    // build this method by hand. However, we want to take advantage of generic deriving generating
+    // the `Generics` for us. So we'll generate an empty impl, then later on add our method. It's
+    // not pretty, but it works until we get a more general purpose ast builder.
+    match item.node {
+        ast::ItemStruct(_, ref generics) | ast::ItemEnum(_, ref generics) => {
+            if generics.is_type_parameterized() {
+                partial_ord::expand_deriving_partial_ord(cx, span, mitem, item, push);
+                return;
+            }
+        }
+        _ => {
+            cx.span_err(mitem.span, "`derive` may only be applied to structs and enums");
+            return;
+        }
+    }
+
+    let trait_def = TraitDef {
+        span: span,
+        attributes: Vec::new(),
+        path: path_std!(cx, core::cmp::PartialOrd),
+        additional_bounds: Vec::new(),
+        generics: LifetimeBounds::empty(),
+        methods: Vec::new(),
+        associated_types: Vec::new(),
+    };
+
+    // We want to use the `cx` to build our ast, but it's passed by `&mut` to the expand method. So
+    // we'll extract out the generated item by way of an option.
+    let mut expanded_item = None;
+
+    trait_def.expand(cx, mitem, item, &mut |item: P<ast::Item>| {
+        expanded_item = Some(item);
+    });
+
+    let expanded_item = expanded_item.unwrap().map(|mut item| {
+        match item.node {
+            ast::ItemImpl(_, _, _, _, ref ty, ref mut impl_items) => {
+                let self_arg = ast::Arg::new_self(span, ast::MutImmutable, special_idents::self_);
+                let other_arg = cx.arg(
+                    span,
+                    cx.ident_of("other"),
+                    cx.ty_rptr(
+                        span,
+                        ty.clone(),
+                        None,
+                        ast::Mutability::MutImmutable,
+                    ),
+                );
+                let decl = cx.fn_decl(
+                    vec![self_arg, other_arg],
+                    cx.ty_option(
+                        cx.ty_path(
+                            cx.path_global(
+                                span,
+                                vec![
+                                    cx.ident_of_std("core"),
+                                    cx.ident_of("cmp"),
+                                    cx.ident_of("Ordering"),
+                                ],
+                            )
+                        )
+                    )
+                );
+
+                let sig = ast::MethodSig {
+                    unsafety: ast::Unsafety::Normal,
+                    abi: abi::Rust,
+                    decl: decl.clone(),
+                    generics: ast::Generics {
+                        lifetimes: Vec::new(),
+                        ty_params: OwnedSlice::empty(),
+                        where_clause: ast::WhereClause {
+                            id: ast::DUMMY_NODE_ID,
+                            predicates: Vec::new(),
+                        }
+                    },
+                    explicit_self: respan(
+                        span,
+                        ast::SelfRegion(None, ast::MutImmutable, cx.ident_of("self")),
+                    ),
+                };
+
+                let block = cx.block_expr(
+                    cx.expr_some(
+                        span,
+                        cx.expr_call(
+                            span,
+                            cx.expr_path(
+                                cx.path_global(
+                                    span,
+                                    vec![
+                                        cx.ident_of_std("core"),
+                                        cx.ident_of("cmp"),
+                                        cx.ident_of("Ord"),
+                                        cx.ident_of("cmp"),
+                                    ],
+                                ),
+                            ),
+                            vec![
+                                cx.expr_self(span),
+                                cx.expr_addr_of(
+                                    span,
+                                    cx.expr_ident(span, cx.ident_of("other"))
+                                ),
+                            ]
+                        )
+                    )
+                );
+
+                let inline = cx.meta_word(span, InternedString::new("inline"));
+                let attrs = vec!(cx.attribute(span, inline));
+
+                impl_items.push(P(ast::ImplItem {
+                    id: ast::DUMMY_NODE_ID,
+                    ident: cx.ident_of("partial_cmp"),
+                    vis: ast::Visibility::Inherited,
+                    attrs: attrs,
+                    node: ast::ImplItem_::MethodImplItem(sig, block),
+                    span: span,
+                }));
+            }
+            _ => {
+                cx.span_bug(span, "we should have gotten an impl")
+            }
+        };
+
+        item
+    });
+
+    push(expanded_item)
+}