core: Camel case some lesser-used modules

Author: brson

src/libcore/at_vec.rs

@@ -14,7 +14,7 @@ export unsafe;
 
 #[abi = "cdecl"]
 extern mod rustrt {
-    fn vec_reserve_shared_actual(++t: *sys::type_desc,
+    fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
                                  ++v: **vec::unsafe::vec_repr,
                                  ++n: libc::size_t);
 }

src/libcore/cmp.rs

@@ -4,22 +4,22 @@
 
 /// Interfaces used for comparison.
 
-trait ord {
+trait Ord {
     pure fn lt(&&other: self) -> bool;
 }
 
-trait eq {
+trait Eq {
     pure fn eq(&&other: self) -> bool;
 }
 
-pure fn lt<T: ord>(v1: &T, v2: &T) -> bool {
+pure fn lt<T: Ord>(v1: &T, v2: &T) -> bool {
     v1.lt(*v2)
 }
 
-pure fn le<T: ord eq>(v1: &T, v2: &T) -> bool {
+pure fn le<T: Ord Eq>(v1: &T, v2: &T) -> bool {
     v1.lt(*v2) || v1.eq(*v2)
 }
 
-pure fn eq<T: eq>(v1: &T, v2: &T) -> bool {
+pure fn eq<T: Eq>(v1: &T, v2: &T) -> bool {
     v1.eq(*v2)
 }

src/libcore/core.rc

@@ -159,17 +159,22 @@ mod ptr;
 mod vec;
 mod at_vec;
 mod bool;
+#[warn(non_camel_case_types)]
 mod tuple;
 
 // Ubiquitous-utility-type modules
 
 #[cfg(notest)]
 mod ops;
+#[warn(non_camel_case_types)]
 mod cmp;
+#[warn(non_camel_case_types)]
 mod num;
+#[warn(non_camel_case_types)]
 mod hash;
 mod either;
 mod iter;
+#[warn(non_camel_case_types)]
 mod logging;
 mod option;
 #[path="iter-trait"]
@@ -178,8 +183,11 @@ mod option_iter {
     mod inst;
 }
 mod result;
+#[warn(non_camel_case_types)]
 mod to_str;
+#[warn(non_camel_case_types)]
 mod to_bytes;
+#[warn(non_camel_case_types)]
 mod util;
 
 // Data structure modules
@@ -212,7 +220,9 @@ mod os;
 mod path;
 mod rand;
 mod run;
+#[warn(non_camel_case_types)]
 mod sys;
+#[warn(non_camel_case_types)]
 mod unsafe;
 
 
@@ -227,9 +237,13 @@ mod rt;
 
 // For internal use, not exported
 
+#[warn(non_camel_case_types)]
 mod unicode;
+#[warn(non_camel_case_types)]
 mod priv;
+#[warn(non_camel_case_types)]
 mod cmath;
+#[warn(non_camel_case_types)]
 mod stackwalk;
 
 // Local Variables:

src/libcore/core.rs

@@ -5,27 +5,27 @@
 import option::{some, none};
 import option = option::option;
 import path = path::path;
-import tuple::{tuple_ops, extended_tuple_ops};
+import tuple::{TupleOps, ExtendedTupleOps};
 import str::{str_slice, unique_str};
 import vec::{const_vector, copyable_vector, immutable_vector};
 import vec::{immutable_copyable_vector, iter_trait_extensions};
 import iter::{base_iter, extended_iter, copyable_iter, times, timesi};
-import num::num;
+import num::Num;
 import ptr::ptr;
-import to_str::to_str;
+import to_str::ToStr;
 
 export path, option, some, none, unreachable;
 export extensions;
 // The following exports are the extension impls for numeric types
-export num, times, timesi;
+export Num, times, timesi;
 // The following exports are the common traits
 export str_slice, unique_str;
 export const_vector, copyable_vector, immutable_vector;
 export immutable_copyable_vector, iter_trait_extensions;
 export base_iter, copyable_iter, extended_iter;
-export tuple_ops, extended_tuple_ops;
+export TupleOps, ExtendedTupleOps;
 export ptr;
-export to_str;
+export ToStr;
 
 // The following exports are the core operators and kinds
 // The compiler has special knowlege of these so we must not duplicate them

src/libcore/f32.rs

@@ -167,7 +167,7 @@ pure fn log2(n: f32) -> f32 {
     return ln(n) / consts::ln_2;
 }
 
-impl f32: num::num {
+impl f32: num::Num {
     pure fn add(&&other: f32)    -> f32 { return self + other; }
     pure fn sub(&&other: f32)    -> f32 { return self - other; }
     pure fn mul(&&other: f32)    -> f32 { return self * other; }

src/libcore/f64.rs

@@ -194,7 +194,7 @@ pure fn log2(n: f64) -> f64 {
     return ln(n) / consts::ln_2;
 }
 
-impl f64: num::num {
+impl f64: num::Num {
     pure fn add(&&other: f64)    -> f64 { return self + other; }
     pure fn sub(&&other: f64)    -> f64 { return self - other; }
     pure fn mul(&&other: f64)    -> f64 { return self * other; }

src/libcore/float.rs

@@ -409,7 +409,7 @@ pure fn sin(x: float) -> float { f64::sin(x as f64) as float }
 pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
 pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
-impl float: num::num {
+impl float: num::Num {
     pure fn add(&&other: float)    -> float { return self + other; }
     pure fn sub(&&other: float)    -> float { return self - other; }
     pure fn mul(&&other: float)    -> float { return self * other; }
@@ -516,7 +516,7 @@ fn test_to_str_inf() {
 
 #[test]
 fn test_traits() {
-    fn test<U:num::num>(ten: U) {
+    fn test<U:num::Num>(ten: U) {
         assert (ten.to_int() == 10);
 
         let two = ten.from_int(2);

src/libcore/int-template.rs

@@ -1,5 +1,5 @@
 import T = inst::T;
-import cmp::{eq, ord};
+import cmp::{Eq, Ord};
 
 export min_value, max_value;
 export min, max;
@@ -62,20 +62,20 @@ pure fn abs(i: T) -> T {
     if is_negative(i) { -i } else { i }
 }
 
-impl T: ord {
+impl T: Ord {
     pure fn lt(&&other: T) -> bool {
         return self < other;
     }
 }
 
-impl T: eq {
+impl T: Eq {
     pure fn eq(&&other: T) -> bool {
         return self == other;
     }
 }
 
 
-impl T: num::num {
+impl T: num::Num {
     pure fn add(&&other: T)    -> T { return self + other; }
     pure fn sub(&&other: T)    -> T { return self - other; }
     pure fn mul(&&other: T)    -> T { return self * other; }
@@ -235,7 +235,7 @@ fn test_to_str() {
 
 #[test]
 fn test_interfaces() {
-    fn test<U:num::num>(ten: U) {
+    fn test<U:num::Num>(ten: U) {
         assert (ten.to_int() == 10);
 
         let two = ten.from_int(2);

src/libcore/num.rs

@@ -1,6 +1,6 @@
 /// An interface for numbers.
 
-trait num {
+trait Num {
     // FIXME: Cross-crate overloading doesn't work yet. (#2615)
     // FIXME: Trait composition. (#2616)
     pure fn add(&&other: self) -> self;

src/libcore/option.rs

@@ -227,7 +227,7 @@ fn test_option_dance() {
 }
 #[test] #[should_fail] #[ignore(cfg(windows))]
 fn test_option_too_much_dance() {
-    let mut y = some(util::noncopyable());
+    let mut y = some(util::NonCopyable());
     let _y2 = swap_unwrap(&mut y);
     let _y3 = swap_unwrap(&mut y);
 }

src/libcore/pipes.rs

@@ -1081,7 +1081,7 @@ impl<T: send> port<T>: selectable {
 }
 
 /// A channel that can be shared between many senders.
-type shared_chan<T: send> = unsafe::exclusive<chan<T>>;
+type shared_chan<T: send> = unsafe::Exclusive<chan<T>>;
 
 impl<T: send> shared_chan<T>: channel<T> {
     fn send(+x: T) {

src/libcore/priv.rs

@@ -5,6 +5,7 @@ export chan_from_global_ptr, weaken_task;
 import compare_and_swap = rustrt::rust_compare_and_swap_ptr;
 import task::task_builder;
 
+#[allow(non_camel_case_types)] // runtime type
 type rust_port_id = uint;
 
 extern mod rustrt {
@@ -15,22 +16,22 @@ extern mod rustrt {
     fn rust_task_unweaken(ch: rust_port_id);
 }
 
-type global_ptr = *libc::uintptr_t;
+type GlobalPtr = *libc::uintptr_t;
 
 /**
  * Atomically gets a channel from a pointer to a pointer-sized memory location
  * or, if no channel exists creates and installs a new channel and sets up a
  * new task to receive from it.
  */
 unsafe fn chan_from_global_ptr<T: send>(
-    global: global_ptr,
+    global: GlobalPtr,
     task_fn: fn() -> task::task_builder,
     +f: fn~(comm::port<T>)
 ) -> comm::chan<T> {
 
-    enum msg {
-        proceed,
-        abort
+    enum Msg {
+        Proceed,
+        Abort
     }
 
     log(debug,~"ENTERING chan_from_global_ptr, before is_prob_zero check");
@@ -48,9 +49,9 @@ unsafe fn chan_from_global_ptr<T: send>(
 
             // Wait to hear if we are the official instance of
             // this global task
-            match comm::recv::<msg>(setup_po) {
-              proceed => f(po),
-              abort => ()
+            match comm::recv::<Msg>(setup_po) {
+              Proceed => f(po),
+              Abort => ()
             }
         };
 
@@ -68,11 +69,11 @@ unsafe fn chan_from_global_ptr<T: send>(
 
         if swapped {
             // Success!
-            comm::send(setup_ch, proceed);
+            comm::send(setup_ch, Proceed);
             ch
         } else {
             // Somebody else got in before we did
-            comm::send(setup_ch, abort);
+            comm::send(setup_ch, Abort);
             unsafe::reinterpret_cast(*global)
         }
     } else {
@@ -186,10 +187,10 @@ unsafe fn weaken_task(f: fn(comm::port<()>)) {
     unsafe {
         rustrt::rust_task_weaken(unsafe::reinterpret_cast(ch));
     }
-    let _unweaken = unweaken(ch);
+    let _unweaken = Unweaken(ch);
     f(po);
 
-    class unweaken {
+    class Unweaken {
       let ch: comm::chan<()>;
       new(ch: comm::chan<()>) { self.ch = ch; }
       drop unsafe {

src/libcore/stackwalk.rs

@@ -4,32 +4,32 @@ import unsafe::reinterpret_cast;
 import ptr::offset;
 import sys::size_of;
 
-type word = uint;
+type Word = uint;
 
-class frame {
-    let fp: *word;
+class Frame {
+    let fp: *Word;
 
-    new(fp: *word) {
+    new(fp: *Word) {
         self.fp = fp;
     }
 }
 
-fn walk_stack(visit: fn(frame) -> bool) {
+fn walk_stack(visit: fn(Frame) -> bool) {
 
     debug!{"beginning stack walk"};
 
     do frame_address |frame_pointer| {
-        let mut frame_address: *word = unsafe {
+        let mut frame_address: *Word = unsafe {
             reinterpret_cast(frame_pointer)
         };
         loop {
-            let fr = frame(frame_address);
+            let fr = Frame(frame_address);
 
             debug!{"frame: %x", unsafe { reinterpret_cast(fr.fp) }};
             visit(fr);
 
             unsafe {
-                let next_fp: **word = reinterpret_cast(frame_address);
+                let next_fp: **Word = reinterpret_cast(frame_address);
                 frame_address = *next_fp;
                 if *frame_address == 0u {
                     debug!{"encountered task_start_wrapper. ending walk"};

src/libcore/sys.rs

@@ -1,6 +1,6 @@
 //! Misc low level stuff
 
-export type_desc;
+export TypeDesc;
 export get_type_desc;
 export size_of;
 export min_align_of;
@@ -9,15 +9,16 @@ export refcount;
 export log_str;
 export shape_eq, shape_lt, shape_le;
 
-enum type_desc = {
+// Corresponds to runtime type_desc type
+enum TypeDesc = {
     size: uint,
     align: uint
     // Remaining fields not listed
 };
 
 #[abi = "cdecl"]
 extern mod rustrt {
-    pure fn shape_log_str(t: *sys::type_desc, data: *()) -> ~str;
+    pure fn shape_log_str(t: *sys::TypeDesc, data: *()) -> ~str;
 }
 
 #[abi = "rust-intrinsic"]
@@ -48,8 +49,8 @@ pure fn shape_le<T>(x1: &T, x2: &T) -> bool {
  * Useful for calling certain function in the Rust runtime or otherwise
  * performing dark magick.
  */
-pure fn get_type_desc<T>() -> *type_desc {
-    unchecked { rusti::get_tydesc::<T>() as *type_desc }
+pure fn get_type_desc<T>() -> *TypeDesc {
+    unchecked { rusti::get_tydesc::<T>() as *TypeDesc }
 }
 
 /// Returns the size of a type