---

yaml
---
r: 63079
b: refs/heads/snap-stage3
c: ebf7281
h: refs/heads/master
i:
  63077: a47f4eb
  63075: 59abfba
  63071: 315fb59
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: af863cf2a4b8d14483d5ba34d29d1040ae740891
+refs/heads/snap-stage3: ebf7281b7b16d5083d1a6d114ae49e6f878c72d3
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -476,91 +476,103 @@ pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) -> bool {
 }
 
 /// Iterates over all the paths in the given crate.
-pub fn each_path(intr: @ident_interner,
-                 cdata: cmd,
-                 get_crate_data: GetCrateDataCb,
-                 f: &fn(&str, def_like, ast::visibility) -> bool)
-                 -> bool {
-    // FIXME #4572: This function needs to be nuked, as it's impossible to make fast.
-    // It's the source of most of the performance problems when compiling small crates.
-
+pub fn _each_path(intr: @ident_interner,
+                  cdata: cmd,
+                  get_crate_data: GetCrateDataCb,
+                  f: &fn(&str, def_like, ast::visibility) -> bool)
+                  -> bool {
     let root = reader::Doc(cdata.data);
     let items = reader::get_doc(root, tag_items);
     let items_data = reader::get_doc(items, tag_items_data);
 
+    let mut broken = false;
+
     // First, go through all the explicit items.
     for reader::tagged_docs(items_data, tag_items_data_item) |item_doc| {
-        let path = ast_map::path_to_str(item_path(item_doc), intr);
-        let path_is_empty = path.is_empty();
-        if !path_is_empty {
-            // Extract the def ID.
-            let def_id = item_def_id(item_doc, cdata);
-
-            // Construct the def for this item.
-            debug!("(each_path) yielding explicit item: %s", path);
-            let def_like = item_to_def_like(item_doc, def_id, cdata.cnum);
-
-            let vis = item_visibility(item_doc);
-
-            // Hand the information off to the iteratee.
-            if !f(path, def_like, vis) {
-                return false;
+        if !broken {
+            let path = ast_map::path_to_str_with_sep(
+                item_path(item_doc), "::", intr);
+            let path_is_empty = path.is_empty();
+            if !path_is_empty {
+                // Extract the def ID.
+                let def_id = item_def_id(item_doc, cdata);
+
+                // Construct the def for this item.
+                debug!("(each_path) yielding explicit item: %s", path);
+                let def_like = item_to_def_like(item_doc, def_id, cdata.cnum);
+
+                let vis = item_visibility(item_doc);
+
+                // Hand the information off to the iteratee.
+                if !f(path, def_like, vis) {
+                    broken = true;      // FIXME #4572: This is awful.
+                }
             }
-        }
 
-        // If this is a module, find the reexports.
-        for each_reexport(item_doc) |reexport_doc| {
-            let def_id_doc =
-                reader::get_doc(reexport_doc,
-                                tag_items_data_item_reexport_def_id);
-            let def_id =
-                reader::with_doc_data(def_id_doc,
-                                      |d| parse_def_id(d));
-            let def_id = translate_def_id(cdata, def_id);
-
-            let reexport_name_doc =
-                reader::get_doc(reexport_doc,
-                                tag_items_data_item_reexport_name);
-            let reexport_name = reader::doc_as_str(reexport_name_doc);
-
-            let reexport_path;
-            if path_is_empty {
-                reexport_path = reexport_name;
-            } else {
-                reexport_path = path + "::" + reexport_name;
-            }
+            // If this is a module, find the reexports.
+            for each_reexport(item_doc) |reexport_doc| {
+                if !broken {
+                    let def_id_doc =
+                        reader::get_doc(reexport_doc,
+                            tag_items_data_item_reexport_def_id);
+                    let def_id =
+                        reader::with_doc_data(def_id_doc,
+                                              |d| parse_def_id(d));
+                    let def_id = translate_def_id(cdata, def_id);
+
+                    let reexport_name_doc =
+                        reader::get_doc(reexport_doc,
+                                      tag_items_data_item_reexport_name);
+                    let reexport_name = reader::doc_as_str(reexport_name_doc);
+
+                    let reexport_path;
+                    if path_is_empty {
+                        reexport_path = reexport_name;
+                    } else {
+                        reexport_path = path + "::" + reexport_name;
+                    }
 
-            // This reexport may be in yet another crate
-            let other_crates_items = if def_id.crate == cdata.cnum {
-                items
-            } else {
-                let crate_data = get_crate_data(def_id.crate);
-                let root = reader::Doc(crate_data.data);
-                reader::get_doc(root, tag_items)
-            };
-
-            // Get the item.
-            match maybe_find_item(def_id.node, other_crates_items) {
-                None => {}
-                Some(item_doc) => {
-                    // Construct the def for this item.
-                    let def_like = item_to_def_like(item_doc,
-                                                    def_id,
-                                                    cdata.cnum);
-
-                    // Hand the information off to the iteratee.
-                    debug!("(each_path) yielding reexported \
-                           item: %s", reexport_path);
-
-                    if (!f(reexport_path, def_like, ast::public)) {
-                        return false;
+                    // This reexport may be in yet another crate
+                    let other_crates_items = if def_id.crate == cdata.cnum {
+                        items
+                    } else {
+                        let crate_data = get_crate_data(def_id.crate);
+                        let root = reader::Doc(crate_data.data);
+                        reader::get_doc(root, tag_items)
+                    };
+
+                    // Get the item.
+                    match maybe_find_item(def_id.node, other_crates_items) {
+                        None => {}
+                        Some(item_doc) => {
+                            // Construct the def for this item.
+                            let def_like = item_to_def_like(item_doc,
+                                                            def_id,
+                                                            cdata.cnum);
+
+                            // Hand the information off to the iteratee.
+                            debug!("(each_path) yielding reexported \
+                                    item: %s", reexport_path);
+
+                            if (!f(reexport_path, def_like, ast::public)) {
+                                broken = true;  // FIXME #4572: This is awful.
+                            }
+                        }
                     }
                 }
             }
         }
     }
 
-    return true;
+    return broken;
+}
+
+pub fn each_path(intr: @ident_interner,
+                 cdata: cmd,
+                 get_crate_data: GetCrateDataCb,
+                 f: &fn(&str, def_like, ast::visibility) -> bool)
+                 -> bool {
+    _each_path(intr, cdata, get_crate_data, f)
 }
 
 pub fn get_item_path(cdata: cmd, id: ast::node_id)

branches/snap-stage3/src/libsyntax/ext/deriving/clone.rs

@@ -38,9 +38,7 @@ pub fn expand_deriving_clone(cx: @ExtCtxt,
         ]
     };
 
-    expand_deriving_generic(cx, span,
-                            mitem, in_items,
-                            &trait_def)
+    trait_def.expand(cx, span, mitem, in_items)
 }
 
 pub fn expand_deriving_deep_clone(cx: @ExtCtxt,
@@ -67,9 +65,7 @@ pub fn expand_deriving_deep_clone(cx: @ExtCtxt,
         ]
     };
 
-    expand_deriving_generic(cx, span,
-                            mitem, in_items,
-                            &trait_def)
+    trait_def.expand(cx, span, mitem, in_items)
 }
 
 fn cs_clone(

branches/snap-stage3/src/libsyntax/ext/deriving/cmp/eq.rs

@@ -54,7 +54,5 @@ pub fn expand_deriving_eq(cx: @ExtCtxt,
             md!("ne", cs_ne)
         ]
     };
-
-    expand_deriving_generic(cx, span, mitem, in_items,
-                            &trait_def)
+    trait_def.expand(cx, span, mitem, in_items)
 }

branches/snap-stage3/src/libsyntax/ext/deriving/cmp/ord.rs

@@ -10,6 +10,7 @@
 
 use core::prelude::*;
 
+use ast;
 use ast::{meta_item, item, expr};
 use codemap::span;
 use ext::base::ExtCtxt;
@@ -21,106 +22,105 @@ pub fn expand_deriving_ord(cx: @ExtCtxt,
                            mitem: @meta_item,
                            in_items: ~[@item]) -> ~[@item] {
     macro_rules! md (
-        ($name:expr, $less:expr, $equal:expr) => {
+        ($name:expr, $func:expr, $op:expr) => {
             MethodDef {
                 name: $name,
                 generics: LifetimeBounds::empty(),
                 explicit_self: borrowed_explicit_self(),
                 args: ~[borrowed_self()],
                 ret_ty: Literal(Path::new(~["bool"])),
                 const_nonmatching: false,
-                combine_substructure: |cx, span, substr|
-                    cs_ord($less, $equal, cx, span, substr)
+                combine_substructure: |cx, span, substr| $func($op, cx, span, substr)
             }
         }
     );
 
-
-
     let trait_def = TraitDef {
         path: Path::new(~["std", "cmp", "Ord"]),
-        // XXX: Ord doesn't imply Eq yet
-        additional_bounds: ~[Literal(Path::new(~["std", "cmp", "Eq"]))],
+        additional_bounds: ~[],
         generics: LifetimeBounds::empty(),
         methods: ~[
-            md!("lt", true,  false),
-            md!("le", true,  true),
-            md!("gt", false, false),
-            md!("ge", false, true)
+            md!("lt", cs_strict, true),
+            md!("le", cs_nonstrict, true), // inverse operation
+            md!("gt", cs_strict, false),
+            md!("ge", cs_nonstrict, false)
         ]
     };
-
-    expand_deriving_generic(cx, span, mitem, in_items,
-                            &trait_def)
+    trait_def.expand(cx, span, mitem, in_items)
 }
 
-/// `less`: is this `lt` or `le`? `equal`: is this `le` or `ge`?
-fn cs_ord(less: bool, equal: bool,
-          cx: @ExtCtxt, span: span,
-          substr: &Substructure) -> @expr {
-    let binop = if less {
-        cx.ident_of("lt")
-    } else {
-        cx.ident_of("gt")
-    };
-    let base = cx.expr_bool(span, equal);
-
+/// Strict inequality.
+fn cs_strict(less: bool, cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
+    let op = if less {ast::lt} else {ast::gt};
     cs_fold(
         false, // need foldr,
         |cx, span, subexpr, self_f, other_fs| {
             /*
-
-            build up a series of nested ifs from the inside out to get
-            lexical ordering (hence foldr), i.e.
+            build up a series of chain ||'s and &&'s from the inside
+            out (hence foldr) to get lexical ordering, i.e. for op ==
+            `ast::lt`
 
             ```
-            if self.f1 `binop` other.f1 {
-                true
-            } else if self.f1 == other.f1 {
-                if self.f2 `binop` other.f2 {
-                    true
-                } else if self.f2 == other.f2 {
-                    `equal`
-                } else {
-                    false
-                }
-            } else {
-                false
-            }
+            self.f1 < other.f1 || (!(other.f1 < self.f1) &&
+                (self.f2 < other.f2 || (!(other.f2 < self.f2) &&
+                    (false)
+                ))
+            )
             ```
 
-            The inner "`equal`" case is only reached if the two
-            items have all fields equal.
+            The optimiser should remove the redundancy. We explicitly
+            get use the binops to avoid auto-deref derefencing too many
+            layers of pointers, if the type includes pointers.
             */
-            if other_fs.len() != 1 {
-                cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`");
-            }
+            let other_f = match other_fs {
+                [o_f] => o_f,
+                _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
+            };
+
+            let cmp = cx.expr_binary(span, op,
+                                     cx.expr_deref(span, self_f),
+                                     cx.expr_deref(span, other_f));
 
-            let cmp = cx.expr_method_call(span,
-                                          self_f, cx.ident_of("eq"), other_fs.to_owned());
-            let elseif = cx.expr_if(span, cmp,
-                                    subexpr, Some(cx.expr_bool(span, false)));
+            let not_cmp = cx.expr_binary(span, op,
+                                         cx.expr_deref(span, other_f),
+                                         cx.expr_deref(span, self_f));
+            let not_cmp = cx.expr_unary(span, ast::not, not_cmp);
 
-            let cmp = cx.expr_method_call(span,
-                                          self_f, binop, other_fs.to_owned());
-            cx.expr_if(span, cmp,
-                        cx.expr_bool(span, true), Some(elseif))
+            let and = cx.expr_binary(span, ast::and,
+                                     not_cmp, subexpr);
+            cx.expr_binary(span, ast::or, cmp, and)
         },
-        base,
+        cx.expr_bool(span, false),
         |cx, span, args, _| {
             // nonmatching enums, order by the order the variants are
             // written
             match args {
                 [(self_var, _, _),
                  (other_var, _, _)] =>
                     cx.expr_bool(span,
-                                   if less {
-                                       self_var < other_var
-                                   } else {
-                                       self_var > other_var
-                                   }),
+                                 if less {
+                                     self_var < other_var
+                                 } else {
+                                     self_var > other_var
+                                 }),
                 _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
             }
         },
         cx, span, substr)
 }
+
+fn cs_nonstrict(less: bool, cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
+    // Example: ge becomes !(*self < *other), le becomes !(*self > *other)
+
+    let inverse_op = if less {ast::gt} else {ast::lt};
+    match substr.self_args {
+        [self_, other] => {
+            let inverse_cmp = cx.expr_binary(span, inverse_op,
+                                             cx.expr_deref(span, self_),
+                                             cx.expr_deref(span, other));
+
+            cx.expr_unary(span, ast::not, inverse_cmp)
+        }
+        _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
+    }
+}

branches/snap-stage3/src/libsyntax/ext/deriving/cmp/totaleq.rs

@@ -42,7 +42,5 @@ pub fn expand_deriving_totaleq(cx: @ExtCtxt,
             }
         ]
     };
-
-    expand_deriving_generic(cx, span, mitem, in_items,
-                            &trait_def)
+    trait_def.expand(cx, span, mitem, in_items)
 }