---

yaml
---
r: 140788
b: refs/heads/try2
c: 92d39fe
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2951527528b39dbf47c02b3d329129d677ddcdfd
+refs/heads/try2: 92d39fe4d5e5ad3d2c2dcafe45eaf6e23edddfd7
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libsyntax/ast_map.rs

@@ -60,12 +60,12 @@ pub fn path_to_str_with_sep(p: &[path_elt], sep: ~str, itr: @ident_interner)
     str::connect(strs, sep)
 }
 
-pub fn path_ident_to_str(p: path, i: ident, itr: @ident_interner) -> ~str {
-    if vec::is_empty(p) {
+pub fn path_ident_to_str(p: &path, i: ident, itr: @ident_interner) -> ~str {
+    if vec::is_empty(*p) {
         //FIXME /* FIXME (#2543) */ copy *i
         copy *itr.get(i)
     } else {
-        fmt!("%s::%s", path_to_str(p, itr), *itr.get(i))
+        fmt!("%s::%s", path_to_str(*p, itr), *itr.get(i))
     }
 }
 
@@ -338,7 +338,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
         fmt!("unknown node (id=%d)", id)
       }
       Some(&node_item(item, path)) => {
-        let path_str = path_ident_to_str(*path, item.ident, itr);
+        let path_str = path_ident_to_str(path, item.ident, itr);
         let item_str = match item.node {
           item_const(*) => ~"const",
           item_fn(*) => ~"fn",
@@ -355,7 +355,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
       }
       Some(&node_foreign_item(item, abi, _, path)) => {
         fmt!("foreign item %s with abi %? (id=%?)",
-             path_ident_to_str(*path, item.ident, itr), abi, id)
+             path_ident_to_str(path, item.ident, itr), abi, id)
       }
       Some(&node_method(m, _, path)) => {
         fmt!("method %s in %s (id=%?)",

branches/try2/src/libsyntax/diagnostic.rs

@@ -184,7 +184,7 @@ fn diagnosticcolor(lvl: level) -> u8 {
     }
 }
 
-fn print_diagnostic(topic: ~str, lvl: level, msg: &str) {
+fn print_diagnostic(topic: &str, lvl: level, msg: &str) {
     let use_color = term::color_supported() &&
         io::stderr().get_type() == io::Screen;
     if !topic.is_empty() {

branches/try2/src/libsyntax/ext/asm.rs

@@ -119,13 +119,13 @@ pub fn expand_asm(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree])
                 cons = str::connect(clobs, ",");
             }
             Options => {
-                let option = *p.parse_str();
+                let option = p.parse_str();
 
-                if option == ~"volatile" {
+                if "volatile" == *option {
                     volatile = true;
-                } else if option == ~"alignstack" {
+                } else if "alignstack" == *option {
                     alignstack = true;
-                } else if option == ~"intel" {
+                } else if "intel" == *option {
                     dialect = ast::asm_intel;
                 }
 

branches/try2/src/libsyntax/ext/auto_encode.rs

@@ -836,7 +836,7 @@ fn mk_struct_deser_impl(
     cx: @ext_ctxt,
     span: span,
     ident: ast::ident,
-    fields: ~[@ast::struct_field],
+    fields: &[@ast::struct_field],
     generics: &ast::Generics
 ) -> @ast::item {
     let fields = do mk_struct_fields(fields).mapi |idx, field| {
@@ -1120,7 +1120,7 @@ fn mk_enum_deser_body(
     ext_cx: @ext_ctxt,
     span: span,
     name: ast::ident,
-    variants: ~[ast::variant]
+    variants: &[ast::variant]
 ) -> @ast::expr {
     let expr_arm_names = build::mk_base_vec_e(
         ext_cx,

branches/try2/src/libsyntax/ext/build.rs

@@ -509,7 +509,7 @@ pub fn mk_unreachable(cx: @ext_ctxt, span: span) -> @ast::expr {
         ],
         ~[
             mk_base_str(cx, span, ~"internal error: entered unreachable code"),
-            mk_base_str(cx, span, loc.file.name),
+            mk_base_str(cx, span, copy loc.file.name),
             mk_uint(cx, span, loc.line),
         ]
     )

branches/try2/src/libsyntax/ext/deriving/clone.rs

@@ -60,19 +60,19 @@ fn cs_clone(cx: @ext_ctxt, span: span,
         build::mk_method_call(cx, span, field, clone_ident, ~[]);
 
     match *substr.fields {
-        Struct(af) => {
+        Struct(ref af) => {
             ctor_ident = ~[ substr.type_ident ];
             all_fields = af;
         }
-        EnumMatching(_, variant, af) => {
+        EnumMatching(_, variant, ref af) => {
             ctor_ident = ~[ variant.node.name ];
             all_fields = af;
         },
         EnumNonMatching(*) => cx.span_bug(span, "Non-matching enum variants in `deriving(Clone)`"),
         StaticEnum(*) | StaticStruct(*) => cx.span_bug(span, "Static method in `deriving(Clone)`")
     }
 
-    match all_fields {
+    match *all_fields {
         [(None, _, _), .. _] => {
             // enum-like
             let subcalls = all_fields.map(|&(_, self_f, _)| subcall(self_f));

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

@@ -65,8 +65,6 @@ fn cs_ord(less: bool, equal: bool,
     let false_blk_expr = build::mk_block(cx, span,
                                          ~[], ~[],
                                          Some(build::mk_bool(cx, span, false)));
-    let true_blk = build::mk_simple_block(cx, span,
-                                          build::mk_bool(cx, span, true));
     let base = build::mk_bool(cx, span, equal);
 
     cs_fold(
@@ -108,6 +106,8 @@ fn cs_ord(less: bool, equal: bool,
 
             let cmp = build::mk_method_call(cx, span,
                                             self_f, binop, other_fs.to_owned());
+            let true_blk = build::mk_simple_block(cx, span,
+                                                  build::mk_bool(cx, span, true));
             let if_ = expr_if(cmp, true_blk, Some(elseif));
 
             build::mk_expr(cx, span, if_)

branches/try2/src/libsyntax/ext/deriving/cmp/totalord.rs

@@ -55,15 +55,16 @@ pub fn ordering_const(cx: @ext_ctxt, span: span, cnst: Ordering) -> @expr {
 
 pub fn cs_cmp(cx: @ext_ctxt, span: span,
               substr: &Substructure) -> @expr {
-    let lexical_ord = ~[cx.ident_of("core"),
-                        cx.ident_of("cmp"),
-                        cx.ident_of("lexical_ordering")];
 
     cs_same_method_fold(
         // foldr (possibly) nests the matches in lexical_ordering better
         false,
         |cx, span, old, new| {
-            build::mk_call_global(cx, span, lexical_ord, ~[old, new])
+            build::mk_call_global(cx, span,
+                                  ~[cx.ident_of("core"),
+                                    cx.ident_of("cmp"),
+                                    cx.ident_of("lexical_ordering")],
+                                  ~[old, new])
         },
         ordering_const(cx, span, Equal),
         |cx, span, list, _| {

branches/try2/src/libsyntax/ext/deriving/generic.rs

@@ -259,14 +259,14 @@ pub enum SubstructureFields<'self> {
     fields: `(field ident, self, [others])`, where the field ident is
     only non-`None` in the case of a struct variant.
     */
-    EnumMatching(uint, ast::variant, ~[(Option<ident>, @expr, ~[@expr])]),
+    EnumMatching(uint, &'self ast::variant, ~[(Option<ident>, @expr, ~[@expr])]),
 
     /**
     non-matching variants of the enum, [(variant index, ast::variant,
     [field ident, fields])] (i.e. all fields for self are in the
     first tuple, for other1 are in the second tuple, etc.)
     */
-    EnumNonMatching(~[(uint, ast::variant, ~[(Option<ident>, @expr)])]),
+    EnumNonMatching(&'self [(uint, ast::variant, ~[(Option<ident>, @expr)])]),
 
     /// A static method where Self is a struct
     StaticStruct(&'self ast::struct_def, Either<uint, ~[ident]>),
@@ -290,7 +290,7 @@ representing each variant: (variant index, ast::variant instance,
 */
 pub type EnumNonMatchFunc<'self> =
     &'self fn(@ext_ctxt, span,
-              ~[(uint, ast::variant,
+              &[(uint, ast::variant,
                  ~[(Option<ident>, @expr)])],
               &[@expr]) -> @expr;
 
@@ -416,8 +416,9 @@ impl<'self> MethodDef<'self> {
         let mut nonstatic = false;
 
         match self.self_ty {
-            Some(self_ptr) => {
-                let (self_expr, self_ty) = ty::get_explicit_self(cx, span, self_ptr);
+            Some(ref self_ptr) => {
+                let (self_expr, self_ty) = ty::get_explicit_self(cx, span,
+                                                                 self_ptr);
 
                 ast_self_ty = self_ty;
                 self_args.push(self_expr);
@@ -616,9 +617,10 @@ impl<'self> MethodDef<'self> {
                                self_args: &[@expr],
                                nonself_args: &[@expr])
         -> @expr {
+        let mut matches = ~[];
         self.build_enum_match(cx, span, enum_def, type_ident,
                               self_args, nonself_args,
-                              None, ~[], 0)
+                              None, &mut matches, 0)
     }
 
 
@@ -650,58 +652,57 @@ impl<'self> MethodDef<'self> {
                         self_args: &[@expr],
                         nonself_args: &[@expr],
                         matching: Option<uint>,
-                        matches_so_far: ~[(uint, ast::variant,
-                                           ~[(Option<ident>, @expr)])],
+                        matches_so_far: &mut ~[(uint, ast::variant,
+                                              ~[(Option<ident>, @expr)])],
                         match_count: uint) -> @expr {
         if match_count == self_args.len() {
             // we've matched against all arguments, so make the final
             // expression at the bottom of the match tree
-            match matches_so_far {
-                [] => cx.span_bug(span, ~"no self match on an enum in generic `deriving`"),
-                _ => {
-                    // we currently have a vec of vecs, where each
-                    // subvec is the fields of one of the arguments,
-                    // but if the variants all match, we want this as
-                    // vec of tuples, where each tuple represents a
-                    // field.
-
-                    let substructure;
-
-                    // most arms don't have matching variants, so do a
-                    // quick check to see if they match (even though
-                    // this means iterating twice) instead of being
-                    // optimistic and doing a pile of allocations etc.
-                    match matching {
-                        Some(variant_index) => {
-                            // `ref` inside let matches is buggy. Causes havoc wih rusc.
-                            // let (variant_index, ref self_vec) = matches_so_far[0];
-                            let (variant, self_vec) = match matches_so_far[0] {
-                                (_, v, ref s) => (v, s)
-                            };
-
-                            let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
-
-                            for matches_so_far.tail().each |&(_, _, other_fields)| {
-                                for other_fields.eachi |i, &(_, other_field)| {
-                                    enum_matching_fields[i].push(other_field);
-                                }
-                            }
-                            let field_tuples =
-                                do vec::map_zip(*self_vec,
-                                             enum_matching_fields) |&(id, self_f), &other| {
-                                (id, self_f, other)
-                            };
-                            substructure = EnumMatching(variant_index, variant, field_tuples);
-                        }
-                        None => {
-                            substructure = EnumNonMatching(matches_so_far);
+            if matches_so_far.len() == 0 {
+                cx.span_bug(span, ~"no self match on an enum in generic \
+                                    `deriving`");
+            }
+            // we currently have a vec of vecs, where each
+            // subvec is the fields of one of the arguments,
+            // but if the variants all match, we want this as
+            // vec of tuples, where each tuple represents a
+            // field.
+
+            let substructure;
+
+            // most arms don't have matching variants, so do a
+            // quick check to see if they match (even though
+            // this means iterating twice) instead of being
+            // optimistic and doing a pile of allocations etc.
+            match matching {
+                Some(variant_index) => {
+                    // `ref` inside let matches is buggy. Causes havoc wih rusc.
+                    // let (variant_index, ref self_vec) = matches_so_far[0];
+                    let (variant, self_vec) = match matches_so_far[0] {
+                        (_, ref v, ref s) => (v, s)
+                    };
+
+                    let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
+
+                    for matches_so_far.tail().each |&(_, _, other_fields)| {
+                        for other_fields.eachi |i, &(_, other_field)| {
+                            enum_matching_fields[i].push(other_field);
                         }
                     }
-                    self.call_substructure_method(cx, span, type_ident,
-                                                  self_args, nonself_args,
-                                                  &substructure)
+                    let field_tuples =
+                        do vec::map_zip(*self_vec,
+                                     enum_matching_fields) |&(id, self_f), &other| {
+                        (id, self_f, other)
+                    };
+                    substructure = EnumMatching(variant_index, variant, field_tuples);
+                }
+                None => {
+                    substructure = EnumNonMatching(*matches_so_far);
                 }
             }
+            self.call_substructure_method(cx, span, type_ident,
+                                          self_args, nonself_args,
+                                          &substructure)
 
         } else {  // there are still matches to create
             let current_match_str = if match_count == 0 {
@@ -712,9 +713,6 @@ impl<'self> MethodDef<'self> {
 
             let mut arms = ~[];
 
-            // this is used as a stack
-            let mut matches_so_far = matches_so_far;
-
             // the code for nonmatching variants only matters when
             // we've seen at least one other variant already
             if self.const_nonmatching && match_count > 0 {
@@ -732,7 +730,7 @@ impl<'self> MethodDef<'self> {
                                                                     current_match_str,
                                                                     ast::m_imm);
 
-                matches_so_far.push((index, *variant, idents));
+                matches_so_far.push((index, /*bad*/ copy *variant, idents));
                 let arm_expr = self.build_enum_match(cx, span,
                                                      enum_def,
                                                      type_ident,
@@ -744,9 +742,10 @@ impl<'self> MethodDef<'self> {
                 arms.push(build::mk_arm(cx, span, ~[ pattern ], arm_expr));
 
                 if enum_def.variants.len() > 1 {
+                    let e = &EnumNonMatching(&[]);
                     let wild_expr = self.call_substructure_method(cx, span, type_ident,
                                                                   self_args, nonself_args,
-                                                                  &EnumNonMatching(~[]));
+                                                                  e);
                     let wild_arm = build::mk_arm(cx, span,
                                                  ~[ build::mk_pat_wild(cx, span) ],
                                                  wild_expr);
@@ -760,7 +759,7 @@ impl<'self> MethodDef<'self> {
                                                                        current_match_str,
                                                                        ast::m_imm);
 
-                    matches_so_far.push((index, *variant, idents));
+                    matches_so_far.push((index, /*bad*/ copy *variant, idents));
                     let new_matching =
                         match matching {
                             _ if match_count == 0 => Some(index),
@@ -850,7 +849,7 @@ pub fn cs_fold(use_foldl: bool,
                cx: @ext_ctxt, span: span,
                substructure: &Substructure) -> @expr {
     match *substructure.fields {
-        EnumMatching(_, _, all_fields) | Struct(all_fields) => {
+        EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
             if use_foldl {
                 do all_fields.foldl(base) |&old, &(_, self_f, other_fs)| {
                     f(cx, span, old, self_f, other_fs)
@@ -861,8 +860,9 @@ pub fn cs_fold(use_foldl: bool,
                 }
             }
         },
-        EnumNonMatching(all_enums) => enum_nonmatch_f(cx, span,
-                                                      all_enums, substructure.nonself_args),
+        EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, span,
+                                                          *all_enums,
+                                                          substructure.nonself_args),
         StaticEnum(*) | StaticStruct(*) => {
             cx.span_bug(span, "Static function in `deriving`")
         }
@@ -885,7 +885,7 @@ pub fn cs_same_method(f: &fn(@ext_ctxt, span, ~[@expr]) -> @expr,
                       cx: @ext_ctxt, span: span,
                       substructure: &Substructure) -> @expr {
     match *substructure.fields {
-        EnumMatching(_, _, all_fields) | Struct(all_fields) => {
+        EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
             // call self_n.method(other_1_n, other_2_n, ...)
             let called = do all_fields.map |&(_, self_field, other_fields)| {
                 build::mk_method_call(cx, span,
@@ -896,8 +896,9 @@ pub fn cs_same_method(f: &fn(@ext_ctxt, span, ~[@expr]) -> @expr,
 
             f(cx, span, called)
         },
-        EnumNonMatching(all_enums) => enum_nonmatch_f(cx, span,
-                                                      all_enums, substructure.nonself_args),
+        EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, span,
+                                                          *all_enums,
+                                                          substructure.nonself_args),
         StaticEnum(*) | StaticStruct(*) => {
             cx.span_bug(span, "Static function in `deriving`")
         }