librustc: Fix merge fallout and test cases.

Author: pcwalton

src/libextra/crypto/digest.rs

@@ -49,9 +49,9 @@ fn to_hex(rr: &[u8]) -> ~str {
     for rr.iter().advance() |b| {
         let hex = uint::to_str_radix(*b as uint, 16u);
         if hex.len() == 1 {
-            s += "0";
+            s.push_char('0');
         }
-        s += hex;
+        s.push_str(hex);
     }
     return s;
 }

src/libextra/terminfo/parm.rs

@@ -470,13 +470,14 @@ priv fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
                         FormatHex|FormatHEX => 16,
                         FormatString => util::unreachable()
                     };
-                    let mut (s,_) = match op {
+                    let (s,_) = match op {
                         FormatDigit => {
                             let sign = if flags.sign { SignAll } else { SignNeg };
                             to_str_bytes_common(&d, radix, false, sign, DigAll)
                         }
                         _ => to_str_bytes_common(&(d as uint), radix, false, SignNone, DigAll)
                     };
+                    let mut s = s;
                     if flags.precision > s.len() {
                         let mut s_ = vec::with_capacity(flags.precision);
                         let n = flags.precision - s.len();

src/librustc/driver/session.rs

@@ -403,8 +403,12 @@ mod test {
 
     fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {
         let mut attrs = ~[];
-        if with_bin { attrs += [make_crate_type_attr(@"bin")]; }
-        if with_lib { attrs += [make_crate_type_attr(@"lib")]; }
+        if with_bin {
+            attrs.push(make_crate_type_attr(@"bin"));
+        }
+        if with_lib {
+            attrs.push(make_crate_type_attr(@"lib"));
+        }
         @codemap::respan(codemap::dummy_sp(), ast::crate_ {
             module: ast::_mod { view_items: ~[], items: ~[] },
             attrs: attrs,

src/librustc/metadata/encoder.rs

@@ -484,7 +484,7 @@ fn each_auxiliary_node_id(item: @item, callback: &fn(node_id) -> bool)
     let mut continue = true;
     match item.node {
         item_enum(ref enum_def, _) => {
-            for enum_def.variants.each |variant| {
+            for enum_def.variants.iter().advance |variant| {
                 continue = callback(variant.node.id);
                 if !continue {
                     break
@@ -516,7 +516,7 @@ fn encode_reexports(ecx: &EncodeContext,
     match ecx.reexports2.find(&id) {
         Some(ref exports) => {
             debug!("(encoding info for module) found reexports for %d", id);
-            for exports.each |exp| {
+            for exports.iter().advance |exp| {
                 debug!("(encoding info for module) reexport '%s' for %d",
                        exp.name, id);
                 ebml_w.start_tag(tag_items_data_item_reexport);
@@ -900,7 +900,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
 
         // Encode all the items in this module.
-        for fm.items.each |foreign_item| {
+        for fm.items.iter().advance |foreign_item| {
             ebml_w.start_tag(tag_mod_child);
             ebml_w.wr_str(def_to_str(local_def(foreign_item.id)));
             ebml_w.end_tag();
@@ -1506,7 +1506,7 @@ fn encode_misc_info(ecx: &EncodeContext,
                     ebml_w: &mut writer::Encoder) {
     ebml_w.start_tag(tag_misc_info);
     ebml_w.start_tag(tag_misc_info_crate_items);
-    for crate.node.module.items.each |&item| {
+    for crate.node.module.items.iter().advance |&item| {
         ebml_w.start_tag(tag_mod_child);
         ebml_w.wr_str(def_to_str(local_def(item.id)));
         ebml_w.end_tag();

src/librustc/middle/reachable.rs

@@ -140,7 +140,7 @@ impl ReachableContext {
                     }
                     item_enum(ref enum_def, _) => {
                         if privacy_context == PublicContext {
-                            for enum_def.variants.each |variant| {
+                            for enum_def.variants.iter().advance |variant| {
                                 reachable_symbols.insert(variant.node.id);
                             }
                         }
@@ -159,7 +159,7 @@ impl ReachableContext {
                         };
 
                         // Mark all public methods as reachable.
-                        for methods.each |&method| {
+                        for methods.iter().advance |&method| {
                             if should_be_considered_public(method) {
                                 reachable_symbols.insert(method.id);
                             }
@@ -168,15 +168,15 @@ impl ReachableContext {
                         if generics_require_inlining(generics) {
                             // If the impl itself has generics, add all public
                             // symbols to the worklist.
-                            for methods.each |&method| {
+                            for methods.iter().advance |&method| {
                                 if should_be_considered_public(method) {
                                     worklist.push(method.id)
                                 }
                             }
                         } else {
                             // Otherwise, add only public methods that have
                             // generics to the worklist.
-                            for methods.each |method| {
+                            for methods.iter().advance |method| {
                                 let generics = &method.generics;
                                 let attrs = &method.attrs;
                                 if generics_require_inlining(generics) ||
@@ -190,7 +190,7 @@ impl ReachableContext {
                     item_trait(_, _, ref trait_methods) => {
                         // Mark all provided methods as reachable.
                         if privacy_context == PublicContext {
-                            for trait_methods.each |trait_method| {
+                            for trait_methods.iter().advance |trait_method| {
                                 match *trait_method {
                                     provided(method) => {
                                         reachable_symbols.insert(method.id);

src/librustc/middle/resolve.rs

@@ -1240,7 +1240,7 @@ impl Resolver {
                 // Create the module and add all methods.
                 match *ty {
                     Ty {
-                        node: ty_path(path, _),
+                        node: ty_path(path, _, _),
                         _
                     } if path.idents.len() == 1 => {
                         let name = path_to_ident(path);

src/librustc/middle/trans/build.rs

@@ -616,7 +616,7 @@ pub fn GEPi(cx: block, base: ValueRef, ixs: &[uint]) -> ValueRef {
     // we care about.
     if ixs.len() < 16 {
         let mut small_vec = [ C_i32(0), ..16 ];
-        for ixs.eachi |i, &ix| {
+        for ixs.iter().enumerate().advance |(i, &ix)| {
             small_vec[i] = C_i32(ix as i32)
         }
         InBoundsGEP(cx, base, small_vec.slice(0, ixs.len()))

src/librustc/middle/trans/cabi_x86_64.rs

@@ -39,7 +39,11 @@ enum RegClass {
     Memory
 }
 
-impl Type {
+trait TypeMethods {
+    fn is_reg_ty(&self) -> bool;
+}
+
+impl TypeMethods for Type {
     fn is_reg_ty(&self) -> bool {
         match self.kind() {
             Integer | Pointer | Float | Double => true,

src/librustc/middle/ty.rs

@@ -1908,7 +1908,7 @@ impl TypeContents {
             // this assertion.
             assert!(self.intersects(TC_OWNED_POINTER));
         }
-        let tc = TC_MANAGED + TC_DTOR + TypeContents::owned(cx);
+        let tc = TC_MANAGED + TC_DTOR + TypeContents::sendable(cx);
         self.intersects(tc)
     }
 

src/librustc/middle/typeck/check/method.rs

@@ -1088,16 +1088,19 @@ impl<'self> LookupContext<'self> {
             _ => {}
         }
 
-        return match candidate.method_ty.explicit_self {
+        let result = match candidate.method_ty.explicit_self {
             sty_static => {
+                debug!("(is relevant?) explicit self is static");
                 false
             }
 
             sty_value => {
+                debug!("(is relevant?) explicit self is by-value");
                 self.fcx.can_mk_subty(rcvr_ty, candidate.rcvr_ty).is_ok()
             }
 
             sty_region(_, m) => {
+                debug!("(is relevant?) explicit self is a region");
                 match ty::get(rcvr_ty).sty {
                     ty::ty_rptr(_, mt) => {
                         mutability_matches(mt.mutbl, m) &&
@@ -1109,6 +1112,7 @@ impl<'self> LookupContext<'self> {
             }
 
             sty_box(m) => {
+                debug!("(is relevant?) explicit self is a box");
                 match ty::get(rcvr_ty).sty {
                     ty::ty_box(mt) => {
                         mutability_matches(mt.mutbl, m) &&
@@ -1120,6 +1124,7 @@ impl<'self> LookupContext<'self> {
             }
 
             sty_uniq(m) => {
+                debug!("(is relevant?) explicit self is a unique pointer");
                 match ty::get(rcvr_ty).sty {
                     ty::ty_uniq(mt) => {
                         mutability_matches(mt.mutbl, m) &&
@@ -1131,6 +1136,10 @@ impl<'self> LookupContext<'self> {
             }
         };
 
+        debug!("(is relevant?) %s", if result { "yes" } else { "no" });
+
+        return result;
+
         fn mutability_matches(self_mutbl: ast::mutability,
                               candidate_mutbl: ast::mutability) -> bool {
             //! True if `self_mutbl <: candidate_mutbl`