Another rollup to cut down on the PR queue

src/libextra/crypto/sha1.rs

@@ -159,7 +159,7 @@ impl Sha1 {
 }
 
 impl Digest for Sha1 {
-    pub fn reset(&mut self) {
+    fn reset(&mut self) {
         self.length_bits = 0;
         self.h[0] = 0x67452301u32;
         self.h[1] = 0xEFCDAB89u32;
@@ -169,9 +169,9 @@ impl Digest for Sha1 {
         self.buffer.reset();
         self.computed = false;
     }
-    pub fn input(&mut self, msg: &[u8]) { add_input(self, msg); }
-    pub fn result(&mut self, out: &mut [u8]) { return mk_result(self, out); }
-    pub fn output_bits(&self) -> uint { 160 }
+    fn input(&mut self, msg: &[u8]) { add_input(self, msg); }
+    fn result(&mut self, out: &mut [u8]) { return mk_result(self, out); }
+    fn output_bits(&self) -> uint { 160 }
 }
 
 #[cfg(test)]

src/libextra/ebml.rs

@@ -305,7 +305,7 @@ pub mod reader {
                     self.pos = r_doc.end;
                     let str = r_doc.as_str_slice();
                     if lbl != str {
-                        fail!("Expected label %s but found %s", lbl, str);
+                        fail!("Expected label %s, found %s", lbl, str);
                     }
                 }
             }
@@ -326,7 +326,7 @@ pub mod reader {
                    r_doc.start,
                    r_doc.end);
             if r_tag != (exp_tag as uint) {
-                fail!("expected EBML doc with tag %? but found tag %?", exp_tag, r_tag);
+                fail!("expected EBML doc with tag %?, found tag %?", exp_tag, r_tag);
             }
             if r_doc.end > self.parent.end {
                 fail!("invalid EBML, child extends to 0x%x, parent to 0x%x",

src/libextra/enum_set.rs

@@ -21,9 +21,9 @@ pub struct EnumSet<E> {
 /// An iterface for casting C-like enum to uint and back.
 pub trait CLike {
     /// Converts C-like enum to uint.
-    pub fn to_uint(&self) -> uint;
+    fn to_uint(&self) -> uint;
     /// Converts uint to C-like enum.
-    pub fn from_uint(uint) -> Self;
+    fn from_uint(uint) -> Self;
 }
 
 fn bit<E:CLike>(e: E) -> uint {
@@ -142,11 +142,11 @@ mod test {
     }
 
     impl CLike for Foo {
-        pub fn to_uint(&self) -> uint {
+        fn to_uint(&self) -> uint {
             *self as uint
         }
 
-        pub fn from_uint(v: uint) -> Foo {
+        fn from_uint(v: uint) -> Foo {
             unsafe { cast::transmute(v) }
         }
     }

src/libextra/num/bigint.rs

@@ -537,7 +537,7 @@ impl ToStrRadix for BigUint {
 impl FromStrRadix for BigUint {
     /// Creates and initializes an BigUint.
 
-    pub fn from_str_radix(s: &str, radix: uint)
+    fn from_str_radix(s: &str, radix: uint)
         -> Option<BigUint> {
         BigUint::parse_bytes(s.as_bytes(), radix)
     }

src/libextra/terminfo/parser/compiled.rs

@@ -178,7 +178,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
     // Check magic number
     let magic = file.read_le_u16();
     if (magic != 0x011A) {
-        return Err(fmt!("invalid magic number: expected %x but found %x", 0x011A, magic as uint));
+        return Err(fmt!("invalid magic number: expected %x, found %x", 0x011A, magic as uint));
     }
 
     let names_bytes          = file.read_le_i16() as int;
@@ -196,19 +196,19 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
     debug!("string_table_bytes = %?", string_table_bytes);
 
     if (bools_bytes as uint) > boolnames.len() {
-        error!("expected bools_bytes to be less than %? but found %?", boolnames.len(),
+        error!("expected bools_bytes to be less than %?, found %?", boolnames.len(),
                bools_bytes);
         return Err(~"incompatible file: more booleans than expected");
     }
 
     if (numbers_count as uint) > numnames.len() {
-        error!("expected numbers_count to be less than %? but found %?", numnames.len(),
+        error!("expected numbers_count to be less than %?, found %?", numnames.len(),
                numbers_count);
         return Err(~"incompatible file: more numbers than expected");
     }
 
     if (string_offsets_count as uint) > stringnames.len() {
-        error!("expected string_offsets_count to be less than %? but found %?", stringnames.len(),
+        error!("expected string_offsets_count to be less than %?, found %?", stringnames.len(),
                string_offsets_count);
         return Err(~"incompatible file: more string offsets than expected");
     }

src/libextra/test.rs

@@ -104,7 +104,7 @@ pub struct Metric {
 pub struct MetricMap(TreeMap<~str,Metric>);
 
 impl Clone for MetricMap {
-    pub fn clone(&self) -> MetricMap {
+    fn clone(&self) -> MetricMap {
         MetricMap((**self).clone())
     }
 }

src/libextra/treemap.rs

@@ -895,7 +895,7 @@ impl<K: TotalOrd, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for TreeMap<K, V
 }
 
 impl<T: TotalOrd, Iter: Iterator<T>> FromIterator<T, Iter> for TreeSet<T> {
-    pub fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
+    fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
         let mut set = TreeSet::new();
         set.extend(iter);
         set

src/libextra/url.rs

@@ -701,7 +701,7 @@ pub fn to_str(url: &Url) -> ~str {
 }
 
 impl ToStr for Url {
-    pub fn to_str(&self) -> ~str {
+    fn to_str(&self) -> ~str {
         to_str(self)
     }
 }

src/librustc/lib/llvm.rs

@@ -2082,6 +2082,9 @@ pub mod llvm {
                                             Elements: ValueRef,
                                             RunTimeLang: c_uint)
                                             -> ValueRef;
+
+        #[fast_ffi]
+        pub fn LLVMSetUnnamedAddr(GlobalVar: ValueRef, UnnamedAddr: Bool);
     }
 }
 
@@ -2101,6 +2104,12 @@ pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
     }
 }
 
+pub fn SetUnnamedAddr(Global: ValueRef, Unnamed: bool) {
+    unsafe {
+        llvm::LLVMSetUnnamedAddr(Global, Unnamed as Bool);
+    }
+}
+
 pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
     unsafe {
         llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)

src/librustc/metadata/tydecode.rs

@@ -542,12 +542,12 @@ pub fn parse_def_id(buf: &[u8]) -> ast::def_id {
 
     let crate_num = match uint::parse_bytes(crate_part, 10u) {
        Some(cn) => cn as int,
-       None => fail!("internal error: parse_def_id: crate number expected, but found %?",
+       None => fail!("internal error: parse_def_id: crate number expected, found %?",
                      crate_part)
     };
     let def_num = match uint::parse_bytes(def_part, 10u) {
        Some(dn) => dn as int,
-       None => fail!("internal error: parse_def_id: id expected, but found %?",
+       None => fail!("internal error: parse_def_id: id expected, found %?",
                      def_part)
     };
     ast::def_id { crate: crate_num, node: def_num }

src/librustc/middle/privacy.rs

@@ -351,6 +351,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
             // Do not check privacy inside items with the resolve_unexported
             // attribute. This is used for the test runner.
             if !attr::contains_name(item.attrs, "!resolve_unexported") {
+                check_sane_privacy(tcx, item);
                 oldvisit::visit_item(item, (method_map, visitor));
             }
         },
@@ -540,3 +541,81 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
     });
     oldvisit::visit_crate(crate, (method_map, visitor));
 }
+
+/// Validates all of the visibility qualifers placed on the item given. This
+/// ensures that there are no extraneous qualifiers that don't actually do
+/// anything. In theory these qualifiers wouldn't parse, but that may happen
+/// later on down the road...
+fn check_sane_privacy(tcx: ty::ctxt, item: @ast::item) {
+    match item.node {
+        // implementations of traits don't need visibility qualifiers because
+        // that's controlled by having the trait in scope.
+        ast::item_impl(_, Some(*), _, ref methods) => {
+            for m in methods.iter() {
+                match m.vis {
+                    ast::private | ast::public => {
+                        tcx.sess.span_err(m.span, "unnecessary visibility")
+                    }
+                    ast::inherited => {}
+                }
+            }
+        }
+
+        ast::item_enum(ref def, _) => {
+            for v in def.variants.iter() {
+                match v.node.vis {
+                    ast::public => {
+                        if item.vis == ast::public {
+                            tcx.sess.span_err(v.span, "unnecessary `pub` \
+                                                       visibility");
+                        }
+                    }
+                    ast::private => {
+                        if item.vis != ast::public {
+                            tcx.sess.span_err(v.span, "unnecessary `priv` \
+                                                       visibility");
+                        }
+                    }
+                    ast::inherited => {}
+                }
+            }
+        }
+
+        ast::item_struct(ref def, _) => {
+            for f in def.fields.iter() {
+                match f.node.kind {
+                    ast::named_field(_, ast::public) => {
+                        tcx.sess.span_err(f.span, "unnecessary `pub` \
+                                                   visibility");
+                    }
+                    ast::named_field(_, ast::private) => {
+                        // Fields should really be private by default...
+                    }
+                    ast::named_field(*) | ast::unnamed_field => {}
+                }
+            }
+        }
+
+        ast::item_trait(_, _, ref methods) => {
+            for m in methods.iter() {
+                match *m {
+                    ast::provided(ref m) => {
+                        match m.vis {
+                            ast::private | ast::public => {
+                                tcx.sess.span_err(m.span, "unnecessary \
+                                                           visibility");
+                            }
+                            ast::inherited => {}
+                        }
+                    }
+                    // this is warned about in the parser
+                    ast::required(*) => {}
+                }
+            }
+        }
+
+        ast::item_impl(*) | ast::item_static(*) | ast::item_foreign_mod(*) |
+        ast::item_fn(*) | ast::item_mod(*) | ast::item_ty(*) |
+        ast::item_mac(*) => {}
+    }
+}

src/librustc/middle/trans/_match.rs

@@ -463,7 +463,7 @@ fn assert_is_binding_or_wild(bcx: @mut Block, p: @ast::pat) {
     if !pat_is_binding_or_wild(bcx.tcx().def_map, p) {
         bcx.sess().span_bug(
             p.span,
-            fmt!("Expected an identifier pattern but found p: %s",
+            fmt!("Expected an identifier pattern, found p: %s",
                  p.repr(bcx.tcx())));
     }
 }

src/librustc/middle/trans/base.rs

@@ -165,7 +165,7 @@ impl<'self> StatRecorder<'self> {
 
 #[unsafe_destructor]
 impl<'self> Drop for StatRecorder<'self> {
-    pub fn drop(&self) {
+    fn drop(&self) {
         if self.ccx.sess.trans_stats() {
             let end = time::precise_time_ns();
             let elapsed = ((end - self.start) / 1_000_000) as uint;
@@ -2180,19 +2180,18 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
       }
       ast::item_static(_, m, expr) => {
           consts::trans_const(ccx, m, item.id);
-          // Do static_assert checking. It can't really be done much earlier because we need to get
-          // the value of the bool out of LLVM
-          for attr in item.attrs.iter() {
-              if "static_assert" == attr.name() {
-                  if m == ast::m_mutbl {
-                      ccx.sess.span_fatal(expr.span,
-                                          "cannot have static_assert on a mutable static");
-                  }
-                  let v = ccx.const_values.get_copy(&item.id);
-                  unsafe {
-                      if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
-                          ccx.sess.span_fatal(expr.span, "static assertion failed");
-                      }
+          // Do static_assert checking. It can't really be done much earlier
+          // because we need to get the value of the bool out of LLVM
+          if attr::contains_name(item.attrs, "static_assert") {
+              if m == ast::m_mutbl {
+                  ccx.sess.span_fatal(expr.span,
+                                      "cannot have static_assert on a mutable \
+                                       static");
+              }
+              let v = ccx.const_values.get_copy(&item.id);
+              unsafe {
+                  if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
+                      ccx.sess.span_fatal(expr.span, "static assertion failed");
                   }
               }
           }
@@ -2452,6 +2451,15 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                                     llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
                                 };
 
+                                // Apply the `unnamed_addr` attribute if
+                                // requested
+                                if attr::contains_name(i.attrs,
+                                                       "address_insignificant"){
+                                    lib::llvm::SetUnnamedAddr(g, true);
+                                    lib::llvm::SetLinkage(g,
+                                        lib::llvm::InternalLinkage);
+                                }
+
                                 ccx.item_symbols.insert(i.id, sym);
                                 g
                             }
@@ -2740,6 +2748,60 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
     ifn!("llvm.bswap.i32",[Type::i32()], Type::i32());
     ifn!("llvm.bswap.i64",[Type::i64()], Type::i64());
 
+    ifn!("llvm.sadd.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.sadd.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.sadd.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.sadd.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
+    ifn!("llvm.uadd.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.uadd.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.uadd.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.uadd.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
+    ifn!("llvm.ssub.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.ssub.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.ssub.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.ssub.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
+    ifn!("llvm.usub.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.usub.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.usub.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.usub.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
+    ifn!("llvm.smul.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.smul.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.smul.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.smul.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
+    ifn!("llvm.umul.with.overflow.i8",
+        [Type::i8(), Type::i8()], Type::struct_([Type::i8(), Type::i1()], false));
+    ifn!("llvm.umul.with.overflow.i16",
+        [Type::i16(), Type::i16()], Type::struct_([Type::i16(), Type::i1()], false));
+    ifn!("llvm.umul.with.overflow.i32",
+        [Type::i32(), Type::i32()], Type::struct_([Type::i32(), Type::i1()], false));
+    ifn!("llvm.umul.with.overflow.i64",
+        [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
+
     return intrinsics;
 }