---

yaml
---
r: 29851
b: refs/heads/incoming
c: 74c69e1
h: refs/heads/master
i:
  29849: 6a2a06e
  29847: b9396ed
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 8be0f665bcda9f5e4077d0be6ebc6aa382e72319
+refs/heads/incoming: 74c69e1053188d92b86bc8b28cbf1af87d31ea2d
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/at_vec.rs

@@ -15,7 +15,7 @@ export unsafe;
 #[abi = "cdecl"]
 extern mod rustrt {
     fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
-                                 ++v: **vec::unsafe::vec_repr,
+                                 ++v: **vec::unsafe::VecRepr,
                                  ++n: libc::size_t);
 }
 
@@ -25,13 +25,13 @@ extern mod rusti {
 }
 
 /// A function used to initialize the elements of a vector
-type init_op<T> = fn(uint) -> T;
+type InitOp<T> = fn(uint) -> T;
 
 /// Returns the number of elements the vector can hold without reallocating
 #[inline(always)]
 pure fn capacity<T>(&&v: @[const T]) -> uint {
     unsafe {
-        let repr: **unsafe::vec_repr =
+        let repr: **unsafe::VecRepr =
             ::unsafe::reinterpret_cast(addr_of(v));
         (**repr).alloc / sys::size_of::<T>()
     }
@@ -103,7 +103,7 @@ pure fn map<T, U>(v: &[T], f: fn(T) -> U) -> @[U] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
  */
-pure fn from_fn<T>(n_elts: uint, op: init_op<T>) -> @[T] {
+pure fn from_fn<T>(n_elts: uint, op: InitOp<T>) -> @[T] {
     do build_sized(n_elts) |push| {
         let mut i: uint = 0u;
         while i < n_elts { push(op(i)); i += 1u; }
@@ -133,8 +133,8 @@ impl<T: copy> @[T]: add<&[const T],@[T]> {
 
 
 mod unsafe {
-    type vec_repr = vec::unsafe::vec_repr;
-    type slice_repr = vec::unsafe::slice_repr;
+    type VecRepr = vec::unsafe::VecRepr;
+    type SliceRepr = vec::unsafe::SliceRepr;
 
     /**
      * Sets the length of a vector
@@ -145,13 +145,13 @@ mod unsafe {
      */
     #[inline(always)]
     unsafe fn set_len<T>(&&v: @[const T], new_len: uint) {
-        let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v));
+        let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v));
         (**repr).fill = new_len * sys::size_of::<T>();
     }
 
     #[inline(always)]
     unsafe fn push<T>(&v: @[const T], +initval: T) {
-        let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v));
+        let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v));
         let fill = (**repr).fill;
         if (**repr).alloc > fill {
             push_fast(v, initval);
@@ -163,7 +163,7 @@ mod unsafe {
     // This doesn't bother to make sure we have space.
     #[inline(always)] // really pretty please
     unsafe fn push_fast<T>(&v: @[const T], +initval: T) {
-        let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v));
+        let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v));
         let fill = (**repr).fill;
         (**repr).fill += sys::size_of::<T>();
         let p = ptr::addr_of((**repr).data);
@@ -190,7 +190,7 @@ mod unsafe {
     unsafe fn reserve<T>(&v: @[const T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if capacity(v) < n {
-            let ptr = addr_of(v) as **vec_repr;
+            let ptr = addr_of(v) as **VecRepr;
             rustrt::vec_reserve_shared_actual(sys::get_type_desc::<T>(),
                                               ptr, n as libc::size_t);
         }

branches/incoming/src/libcore/comm.rs

@@ -27,7 +27,7 @@
  * ~~~
  */
 
-import either::either;
+import either::Either;
 import libc::size_t;
 
 export port;
@@ -222,7 +222,7 @@ fn peek_(p: *rust_port) -> bool {
 
 /// Receive on one of two ports
 fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
-    -> either<A, B> {
+    -> Either<A, B> {
     let ports = ~[(**p_a).po, (**p_b).po];
     let yield = 0u, yieldp = ptr::addr_of(yield);
 
@@ -246,9 +246,9 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
     assert resport != ptr::null();
 
     if resport == (**p_a).po {
-        either::left(recv(p_a))
+        either::Left(recv(p_a))
     } else if resport == (**p_b).po {
-        either::right(recv(p_b))
+        either::Right(recv(p_b))
     } else {
         fail ~"unexpected result from rust_port_select";
     }
@@ -355,11 +355,11 @@ fn test_select2_available() {
 
     send(ch_a, ~"a");
 
-    assert select2(po_a, po_b) == either::left(~"a");
+    assert select2(po_a, po_b) == either::Left(~"a");
 
     send(ch_b, ~"b");
 
-    assert select2(po_a, po_b) == either::right(~"b");
+    assert select2(po_a, po_b) == either::Right(~"b");
 }
 
 #[test]
@@ -375,14 +375,14 @@ fn test_select2_rendezvous() {
             send(ch_a, ~"a");
         };
 
-        assert select2(po_a, po_b) == either::left(~"a");
+        assert select2(po_a, po_b) == either::Left(~"a");
 
         do task::spawn {
             for iter::repeat(10u) { task::yield() }
             send(ch_b, ~"b");
         };
 
-        assert select2(po_a, po_b) == either::right(~"b");
+        assert select2(po_a, po_b) == either::Right(~"b");
     }
 }
 
@@ -413,8 +413,8 @@ fn test_select2_stress() {
     let mut bs = 0;
     for iter::repeat(msgs * times * 2u) {
         match select2(po_a, po_b) {
-          either::left(~"a") => as += 1,
-          either::right(~"b") => bs += 1,
+          either::Left(~"a") => as += 1,
+          either::Right(~"b") => bs += 1,
           _ => fail ~"test_select_2_stress failed"
         }
     }

branches/incoming/src/libcore/core.rc

@@ -68,6 +68,7 @@ export priv;
 // Built-in-type support modules
 
 /// Operations and constants for `int`
+#[warn(non_camel_case_types)]
 #[path = "int-template"]
 mod int {
     import inst::{ hash, pow };
@@ -77,34 +78,39 @@ mod int {
 }
 
 /// Operations and constants for `i8`
+#[warn(non_camel_case_types)]
 #[path = "int-template"]
 mod i8 {
     #[path = "i8.rs"]
     mod inst;
 }
 
 /// Operations and constants for `i16`
+#[warn(non_camel_case_types)]
 #[path = "int-template"]
 mod i16 {
     #[path = "i16.rs"]
     mod inst;
 }
 
 /// Operations and constants for `i32`
+#[warn(non_camel_case_types)]
 #[path = "int-template"]
 mod i32 {
     #[path = "i32.rs"]
     mod inst;
 }
 
 /// Operations and constants for `i64`
+#[warn(non_camel_case_types)]
 #[path = "int-template"]
 mod i64 {
     #[path = "i64.rs"]
     mod inst;
 }
 
 /// Operations and constants for `uint`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod uint {
     import inst::{
@@ -119,6 +125,7 @@ mod uint {
 }
 
 /// Operations and constants for `u8`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod u8 {
     import inst::is_ascii;
@@ -129,36 +136,49 @@ mod u8 {
 }
 
 /// Operations and constants for `u16`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod u16 {
     #[path = "u16.rs"]
     mod inst;
 }
 
 /// Operations and constants for `u32`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod u32 {
     #[path = "u32.rs"]
     mod inst;
 }
 
 /// Operations and constants for `u64`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod u64 {
     #[path = "u64.rs"]
     mod inst;
 }
 
 
+#[warn(non_camel_case_types)]
 mod box;
+#[warn(non_camel_case_types)]
 mod char;
+#[warn(non_camel_case_types)]
 mod float;
+#[warn(non_camel_case_types)]
 mod f32;
+#[warn(non_camel_case_types)]
 mod f64;
+#[warn(non_camel_case_types)]
 mod str;
+#[warn(non_camel_case_types)]
 mod ptr;
+#[warn(non_camel_case_types)]
 mod vec;
+#[warn(non_camel_case_types)]
 mod at_vec;
+#[warn(non_camel_case_types)]
 mod bool;
 #[warn(non_camel_case_types)]
 mod tuple;
@@ -173,7 +193,9 @@ mod cmp;
 mod num;
 #[warn(non_camel_case_types)]
 mod hash;
+#[warn(non_camel_case_types)]
 mod either;
+#[warn(non_camel_case_types)]
 mod iter;
 #[warn(non_camel_case_types)]
 mod logging;
@@ -193,18 +215,23 @@ mod util;
 
 // Data structure modules
 
+#[warn(non_camel_case_types)]
 mod dvec;
 #[path="iter-trait"]
+#[warn(non_camel_case_types)]
 mod dvec_iter {
     #[path = "dvec.rs"]
     mod inst;
 }
+#[warn(non_camel_case_types)]
 mod dlist;
 #[path="iter-trait"]
+#[warn(non_camel_case_types)]
 mod dlist_iter {
     #[path ="dlist.rs"]
     mod inst;
 }
+#[warn(non_camel_case_types)]
 mod send_map;
 
 // Concurrency

branches/incoming/src/libcore/core.rs

@@ -6,25 +6,25 @@ import option::{some, none};
 import option = option::option;
 import Path = path::Path;
 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 str::{StrSlice, UniqueStr};
+import vec::{ConstVector, CopyableVector, ImmutableVector};
+import vec::{ImmutableCopyableVector, IterTraitExtensions};
+import iter::{BaseIter, ExtendedIter, CopyableIter, Times, TimesIx};
 import num::Num;
-import ptr::ptr;
+import ptr::Ptr;
 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, TimesIx;
 // 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 StrSlice, UniqueStr;
+export ConstVector, CopyableVector, ImmutableVector;
+export ImmutableCopyableVector, IterTraitExtensions;
+export BaseIter, CopyableIter, ExtendedIter;
 export TupleOps, ExtendedTupleOps;
-export ptr;
+export Ptr;
 export ToStr;
 
 // The following exports are the core operators and kinds