CamelCasify lots of std

Author: bstrie

src/cargo/cargo.rs

@@ -74,7 +74,7 @@ type options = {
 
 enum mode { system_mode, user_mode, local_mode }
 
-fn opts() -> ~[getopts::opt] {
+fn opts() -> ~[getopts::Opt] {
     ~[optflag(~"g"), optflag(~"G"), optflag(~"test"),
      optflag(~"h"), optflag(~"help")]
 }
@@ -387,27 +387,27 @@ fn valid_pkg_name(s: ~str) -> bool {
     s.all(is_valid_digit)
 }
 
-fn parse_source(name: ~str, j: json::json) -> source {
+fn parse_source(name: ~str, j: json::Json) -> source {
     if !valid_pkg_name(name) {
         fail fmt!("'%s' is an invalid source name", name);
     }
 
     match j {
-        json::dict(j) => {
+        json::Dict(j) => {
             let mut url = match j.find(~"url") {
-                Some(json::string(u)) => *u,
+                Some(json::String(u)) => *u,
                 _ => fail ~"needed 'url' field in source"
             };
             let method = match j.find(~"method") {
-                Some(json::string(u)) => *u,
+                Some(json::String(u)) => *u,
                 _ => assume_source_method(url)
             };
             let key = match j.find(~"key") {
-                Some(json::string(u)) => Some(*u),
+                Some(json::String(u)) => Some(*u),
                 _ => None
             };
             let keyfp = match j.find(~"keyfp") {
-                Some(json::string(u)) => Some(*u),
+                Some(json::String(u)) => Some(*u),
                 _ => None
             };
             if method == ~"file" {
@@ -429,7 +429,7 @@ fn try_parse_sources(filename: &Path, sources: map::hashmap<~str, source>) {
     if !os::path_exists(filename)  { return; }
     let c = io::read_whole_file_str(filename);
     match json::from_str(result::get(c)) {
-        Ok(json::dict(j)) => {
+        Ok(json::Dict(j)) => {
           for j.each |k, v| {
                 sources.insert(k, parse_source(k, v));
                 debug!("source: %s", k);
@@ -440,9 +440,9 @@ fn try_parse_sources(filename: &Path, sources: map::hashmap<~str, source>) {
     }
 }
 
-fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
+fn load_one_source_package(src: source, p: map::hashmap<~str, json::Json>) {
     let name = match p.find(~"name") {
-        Some(json::string(n)) => {
+        Some(json::String(n)) => {
             if !valid_pkg_name(*n) {
                 warn(~"malformed source json: "
                      + src.name + ~", '" + *n + ~"'"+
@@ -459,7 +459,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
     };
 
     let uuid = match p.find(~"uuid") {
-        Some(json::string(n)) => {
+        Some(json::String(n)) => {
             if !is_uuid(*n) {
                 warn(~"malformed source json: "
                      + src.name + ~", '" + *n + ~"'"+
@@ -475,15 +475,15 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
     };
 
     let url = match p.find(~"url") {
-        Some(json::string(n)) => *n,
+        Some(json::String(n)) => *n,
         _ => {
             warn(~"malformed source json: " + src.name + ~" (missing url)");
             return;
         }
     };
 
     let method = match p.find(~"method") {
-        Some(json::string(n)) => *n,
+        Some(json::String(n)) => *n,
         _ => {
             warn(~"malformed source json: "
                  + src.name + ~" (missing method)");
@@ -492,16 +492,16 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
     };
 
     let reference = match p.find(~"ref") {
-        Some(json::string(n)) => Some(*n),
+        Some(json::String(n)) => Some(*n),
         _ => None
     };
 
     let mut tags = ~[];
     match p.find(~"tags") {
-        Some(json::list(js)) => {
+        Some(json::List(js)) => {
           for (*js).each |j| {
                 match j {
-                    json::string(j) => vec::grow(tags, 1u, *j),
+                    json::String(j) => vec::grow(tags, 1u, *j),
                     _ => ()
                 }
             }
@@ -510,7 +510,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
     }
 
     let description = match p.find(~"description") {
-        Some(json::string(n)) => *n,
+        Some(json::String(n)) => *n,
         _ => {
             warn(~"malformed source json: " + src.name
                  + ~" (missing description)");
@@ -548,8 +548,8 @@ fn load_source_info(c: cargo, src: source) {
     if !os::path_exists(&srcfile) { return; }
     let srcstr = io::read_whole_file_str(&srcfile);
     match json::from_str(result::get(srcstr)) {
-        Ok(json::dict(s)) => {
-            let o = parse_source(src.name, json::dict(s));
+        Ok(json::Dict(s)) => {
+            let o = parse_source(src.name, json::Dict(s));
 
             src.key = o.key;
             src.keyfp = o.keyfp;
@@ -570,10 +570,10 @@ fn load_source_packages(c: cargo, src: source) {
     if !os::path_exists(&pkgfile) { return; }
     let pkgstr = io::read_whole_file_str(&pkgfile);
     match json::from_str(result::get(pkgstr)) {
-        Ok(json::list(js)) => {
+        Ok(json::List(js)) => {
           for (*js).each |j| {
                 match j {
-                    json::dict(p) => {
+                    json::Dict(p) => {
                         load_one_source_package(src, p);
                     }
                     _ => {
@@ -1551,7 +1551,7 @@ fn dump_cache(c: cargo) {
     need_dir(&c.root);
 
     let out = c.root.push("cache.json");
-    let _root = json::dict(map::str_hash());
+    let _root = json::Dict(map::str_hash());
 
     if os::path_exists(&out) {
         copy_warn(&out, &c.root.push("cache.json.old"));
@@ -1573,24 +1573,24 @@ fn dump_sources(c: cargo) {
     match io::buffered_file_writer(&out) {
         result::Ok(writer) => {
             let hash = map::str_hash();
-            let root = json::dict(hash);
+            let root = json::Dict(hash);
 
           for c.sources.each |k, v| {
                 let chash = map::str_hash();
-                let child = json::dict(chash);
+                let child = json::Dict(chash);
 
-                chash.insert(~"url", json::string(@v.url));
-                chash.insert(~"method", json::string(@v.method));
+                chash.insert(~"url", json::String(@v.url));
+                chash.insert(~"method", json::String(@v.method));
 
                 match copy v.key {
                     Some(key) => {
-                        chash.insert(~"key", json::string(@key));
+                        chash.insert(~"key", json::String(@key));
                     }
                     _ => ()
                 }
                 match copy v.keyfp {
                     Some(keyfp) => {
-                        chash.insert(~"keyfp", json::string(@keyfp));
+                        chash.insert(~"keyfp", json::String(@keyfp));
                     }
                     _ => ()
                 }

src/compiletest/compiletest.rs

@@ -42,7 +42,7 @@ fn parse_config(args: ~[~str]) -> config {
           Err(f) => fail getopts::fail_str(f)
         };
 
-    fn opt_path(m: getopts::matches, nm: ~str) -> Path {
+    fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
         Path(getopts::opt_str(m, nm))
     }
 

src/libstd/arena.rs

@@ -1,4 +1,5 @@
 // Dynamic arenas.
+#[warn(non_camel_case_types)];
 
 // Arenas are used to quickly allocate objects that share a
 // lifetime. The arena uses ~[u8] vectors as a backing store to
@@ -22,7 +23,7 @@
 // overhead when initializing plain-old-data and means we don't need
 // to waste time running the destructors of POD.
 
-export arena, arena_with_size;
+export Arena, arena_with_size;
 
 import list;
 import list::{list, cons, nil};
@@ -46,15 +47,15 @@ const tydesc_drop_glue_index: size_t = 3 as size_t;
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
 // will always stay at 0.
-type chunk = {data: @[u8], mut fill: uint, is_pod: bool};
+type Chunk = {data: @[u8], mut fill: uint, is_pod: bool};
 
-struct arena {
+struct Arena {
     // The head is seperated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
     // access the head.
-    priv mut head: chunk;
-    priv mut pod_head: chunk;
-    priv mut chunks: @list<chunk>;
+    priv mut head: Chunk;
+    priv mut pod_head: Chunk;
+    priv mut chunks: @list<Chunk>;
     drop {
         unsafe {
             destroy_chunk(self.head);
@@ -65,19 +66,19 @@ struct arena {
     }
 }
 
-fn chunk(size: uint, is_pod: bool) -> chunk {
+fn chunk(size: uint, is_pod: bool) -> Chunk {
     let mut v = @[];
     unsafe { at_vec::unsafe::reserve(v, size); }
     { data: v, mut fill: 0u, is_pod: is_pod }
 }
 
-fn arena_with_size(initial_size: uint) -> arena {
-    return arena {mut head: chunk(initial_size, false),
+fn arena_with_size(initial_size: uint) -> Arena {
+    return Arena {mut head: chunk(initial_size, false),
                   mut pod_head: chunk(initial_size, true),
                   mut chunks: @nil};
 }
 
-fn arena() -> arena {
+fn Arena() -> Arena {
     arena_with_size(32u)
 }
 
@@ -88,7 +89,7 @@ fn round_up_to(base: uint, align: uint) -> uint {
 
 // Walk down a chunk, running the destructors for any objects stored
 // in it.
-unsafe fn destroy_chunk(chunk: chunk) {
+unsafe fn destroy_chunk(chunk: Chunk) {
     let mut idx = 0;
     let buf = vec::unsafe::to_ptr_slice(chunk.data);
     let fill = chunk.fill;
@@ -129,7 +130,7 @@ unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
 }
 
 // The duplication between the POD and non-POD functions is annoying.
-impl &arena {
+impl &Arena {
     // Functions for the POD part of the arena
     fn alloc_pod_grow(n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
@@ -238,7 +239,7 @@ impl &arena {
 
 #[test]
 fn test_arena_destructors() {
-    let arena = arena::arena();
+    let arena = arena::Arena();
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
@@ -251,7 +252,7 @@ fn test_arena_destructors() {
 
 #[test] #[should_fail] #[ignore(cfg(windows))]
 fn test_arena_destructors_fail() {
-    let arena = arena::arena();
+    let arena = arena::Arena();
     // Put some stuff in the arena.
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it

src/libstd/base64.rs

@@ -1,10 +1,11 @@
+#[deny(non_camel_case_types)];
 import io::Reader;
 
-trait to_base64 {
+trait ToBase64 {
     fn to_base64() -> ~str;
 }
 
-impl ~[u8]: to_base64 {
+impl ~[u8]: ToBase64 {
     fn to_base64() -> ~str {
         let chars = str::chars(
           ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
@@ -55,17 +56,17 @@ impl ~[u8]: to_base64 {
     }
 }
 
-impl ~str: to_base64 {
+impl ~str: ToBase64 {
     fn to_base64() -> ~str {
         str::to_bytes(self).to_base64()
     }
 }
 
-trait from_base64 {
+trait FromBase64 {
     fn from_base64() -> ~[u8];
 }
 
-impl ~[u8]: from_base64 {
+impl ~[u8]: FromBase64 {
     fn from_base64() -> ~[u8] {
         if self.len() % 4u != 0u { fail ~"invalid base64 length"; }
 
@@ -127,7 +128,7 @@ impl ~[u8]: from_base64 {
     }
 }
 
-impl ~str: from_base64 {
+impl ~str: FromBase64 {
     fn from_base64() -> ~[u8] {
         str::to_bytes(self).from_base64()
     }