---

yaml
---
r: 55710
b: refs/heads/master
c: 276293a
h: refs/heads/master
v: v3

Author: Kimundi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f0afe23dce9699f2776907d2adde126baea58f30
+refs/heads/master: 276293af7c0fb901c8344e88562ce635f26f47a9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a

trunk/src/libcore/char.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -234,6 +234,21 @@ pub fn escape_default(c: char) -> ~str {
     }
 }
 
+/// Returns the amount of bytes this character would need if encoded in utf8
+pub fn len_utf8_bytes(c: char) -> uint {
+    static max_one_b: uint = 128u;
+    static max_two_b: uint = 2048u;
+    static max_three_b: uint = 65536u;
+    static max_four_b: uint = 2097152u;
+
+    let code = c as uint;
+    if code < max_one_b { 1u }
+    else if code < max_two_b { 2u }
+    else if code < max_three_b { 3u }
+    else if code < max_four_b { 4u }
+    else { fail!(~"invalid character!") }
+}
+
 /**
  * Compare two chars
  *
@@ -334,7 +349,6 @@ fn test_escape_default() {
     assert_eq!(escape_default('\U0001d4b6'), ~"\\U0001d4b6");
 }
 
-
 #[test]
 fn test_escape_unicode() {
     assert_eq!(escape_unicode('\x00'), ~"\\x00");

trunk/src/libcore/str.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -789,16 +789,18 @@ pub fn each_split_within<'a>(ss: &'a str,
 
 /// Convert a string to lowercase. ASCII only
 pub fn to_lower(s: &str) -> ~str {
-    map(s,
-        |c| unsafe{(libc::tolower(c as libc::c_char)) as char}
-    )
+    do map(s) |c| {
+        assert!(char::is_ascii(c));
+        (unsafe{libc::tolower(c as libc::c_char)}) as char
+    }
 }
 
 /// Convert a string to uppercase. ASCII only
 pub fn to_upper(s: &str) -> ~str {
-    map(s,
-        |c| unsafe{(libc::toupper(c as libc::c_char)) as char}
-    )
+    do map(s) |c| {
+        assert!(char::is_ascii(c));
+        (unsafe{libc::toupper(c as libc::c_char)}) as char
+    }
 }
 
 /**
@@ -3096,12 +3098,11 @@ mod tests {
 
     #[test]
     fn test_to_lower() {
-        unsafe {
-            assert!(~"" == map(~"",
-                |c| libc::tolower(c as c_char) as char));
-            assert!(~"ymca" == map(~"YMCA",
-                |c| libc::tolower(c as c_char) as char));
-        }
+        // libc::tolower, and hence str::to_lower
+        // are culturally insensitive: they only work for ASCII
+        // (see Issue #1347)
+        assert!(~"" == to_lower(""));
+        assert!(~"ymca" == to_lower("YMCA"));
     }
 
     #[test]
@@ -3666,12 +3667,8 @@ mod tests {
 
     #[test]
     fn test_map() {
-        unsafe {
-            assert!(~"" == map(~"", |c|
-                libc::toupper(c as c_char) as char));
-            assert!(~"YMCA" == map(~"ymca",
-                                  |c| libc::toupper(c as c_char) as char));
-        }
+        assert!(~"" == map(~"", |c| unsafe {libc::toupper(c as c_char)} as char));
+        assert!(~"YMCA" == map(~"ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
     }
 
     #[test]
@@ -3685,11 +3682,11 @@ mod tests {
 
     #[test]
     fn test_any() {
-        assert!(false  == any(~"", char::is_uppercase));
+        assert!(false == any(~"", char::is_uppercase));
         assert!(false == any(~"ymca", char::is_uppercase));
         assert!(true  == any(~"YMCA", char::is_uppercase));
-        assert!(true == any(~"yMCA", char::is_uppercase));
-        assert!(true == any(~"Ymcy", char::is_uppercase));
+        assert!(true  == any(~"yMCA", char::is_uppercase));
+        assert!(true  == any(~"Ymcy", char::is_uppercase));
     }
 
     #[test]

trunk/src/librustc/middle/lint.rs

@@ -260,7 +260,7 @@ pub fn get_lint_dict() -> LintDict {
         (~"unused_unsafe",
          LintSpec {
             lint: unused_unsafe,
-            desc: "unnecessary use of an \"unsafe\" block",
+            desc: "unnecessary use of an \"unsafe\" block or function",
             default: warn
         }),
 
@@ -958,6 +958,17 @@ fn check_fn(tcx: ty::ctxt, fk: &visit::fn_kind, decl: &ast::fn_decl,
             _body: &ast::blk, span: span, id: ast::node_id) {
     debug!("lint check_fn fk=%? id=%?", fk, id);
 
+    // Check for an 'unsafe fn' which doesn't need to be unsafe
+    match *fk {
+        visit::fk_item_fn(_, _, ast::unsafe_fn, _) => {
+            if !tcx.used_unsafe.contains(&id) {
+                tcx.sess.span_lint(unused_unsafe, id, id, span,
+                                   ~"unnecessary \"unsafe\" function");
+            }
+        }
+        _ => ()
+    }
+
     // Check for deprecated modes
     match *fk {
         // don't complain about blocks, since they tend to get their modes

trunk/src/test/compile-fail/unused-unsafe.rs

@@ -18,7 +18,9 @@ fn callback<T>(_f: &fn() -> T) -> T { fail!() }
 
 fn bad1() { unsafe {} }                  //~ ERROR: unnecessary "unsafe" block
 fn bad2() { unsafe { bad1() } }          //~ ERROR: unnecessary "unsafe" block
-unsafe fn bad4() { unsafe {} }           //~ ERROR: unnecessary "unsafe" block
+unsafe fn bad3() {}                      //~ ERROR: unnecessary "unsafe" function
+unsafe fn bad4() { unsafe {} }           //~ ERROR: unnecessary "unsafe" function
+                                         //~^ ERROR: unnecessary "unsafe" block
 fn bad5() { unsafe { do callback {} } }  //~ ERROR: unnecessary "unsafe" block
 
 unsafe fn good0() { libc::exit(1) }
@@ -36,6 +38,7 @@ fn good2() {
     }
 }
 
-#[allow(unused_unsafe)] fn allowed() { unsafe {} }
+#[allow(unused_unsafe)] unsafe fn allowed0() {}
+#[allow(unused_unsafe)] fn allowed1() { unsafe {} }
 
 fn main() { }