---

yaml
---
r: 30294
b: refs/heads/incoming
c: 959f76d
h: refs/heads/master
v: v3

Author: jimblandy

[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: 7550e459304b2209fbd9c9b61c113d6584ab5a2c
+refs/heads/incoming: 959f76ddeb795298b88ef42da0c69fa5198f4fe8
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/tutorial.md

@@ -2593,7 +2593,7 @@ let result = port.recv();
 ## Creating a task with a bi-directional communication path
 
 A very common thing to do is to spawn a child task where the parent
-and child both need to exchange messages with each other. There
+and child both need to exchange messages with each other. The
 function `std::comm::DuplexStream()` supports this pattern.  We'll
 look briefly at how it is used.
 

branches/incoming/src/libcore/at_vec.rs

@@ -133,7 +133,7 @@ pure fn from_elem<T: copy>(n_elts: uint, t: T) -> @[T] {
 }
 
 #[cfg(notest)]
-impl<T: copy> @[T]: Add<&[const T],@[T]> {
+impl<T: copy> @[T]: add<&[const T],@[T]> {
     #[inline(always)]
     pure fn add(rhs: &[const T]) -> @[T] {
         append(self, rhs)

branches/incoming/src/libcore/core.rc

@@ -31,9 +31,7 @@
 // Don't link to core. We are core.
 #[no_core];
 
-#[warn(vecs_implicitly_copyable)];
-// XXX: Switch to deny after snapshot
-#[warn(non_camel_case_types)];
+#[allow(vecs_implicitly_copyable)];
 
 export int, i8, i16, i32, i64;
 export uint, u8, u16, u32, u64;
@@ -49,7 +47,6 @@ export extfmt;
 export rt;
 export tuple;
 export to_str, to_bytes;
-export from_str;
 export util;
 export dvec, dvec_iter;
 export dlist, dlist_iter;
@@ -74,6 +71,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 };
@@ -83,34 +81,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::{
@@ -125,6 +128,7 @@ mod uint {
 }
 
 /// Operations and constants for `u8`
+#[warn(non_camel_case_types)]
 #[path = "uint-template"]
 mod u8 {
     import inst::is_ascii;
@@ -135,50 +139,72 @@ 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;
+#[warn(non_camel_case_types)]
 mod unit;
+#[warn(non_camel_case_types)]
 mod uniq;
 
 // 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;
+#[warn(non_camel_case_types)]
 mod either;
+#[warn(non_camel_case_types)]
 mod iter;
+#[warn(non_camel_case_types)]
 mod logging;
 mod option;
 #[path="iter-trait"]
@@ -187,42 +213,60 @@ mod option_iter {
     mod inst;
 }
 mod result;
+#[warn(non_camel_case_types)]
 mod to_str;
+#[warn(non_camel_case_types)]
 mod to_bytes;
-mod from_str;
+#[warn(non_camel_case_types)]
 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
+#[warn(non_camel_case_types)]
 mod comm;
+#[warn(non_camel_case_types)]
 mod task;
+//#[warn(non_camel_ase_types)] pipec code continues to trip this warning
 mod future;
+#[warn(non_camel_case_types)]
 mod pipes;
 
 // Runtime and language-primitive support
 
+#[warn(non_camel_case_types)]
 mod io;
 mod libc;
+#[warn(non_camel_case_types)]
 mod os;
+#[warn(non_camel_case_types)]
 mod path;
+#[warn(non_camel_case_types)]
 mod rand;
+#[warn(non_camel_case_types)]
 mod run;
+#[warn(non_camel_case_types)]
 mod sys;
+#[warn(non_camel_case_types)]
 mod unsafe;
 
 mod managed;
@@ -240,9 +284,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:

branches/incoming/src/libcore/core.rs

@@ -44,28 +44,28 @@ export ToStr;
 // The compiler has special knowlege of these so we must not duplicate them
 // when compiling for testing
 #[cfg(notest)]
-import ops::{Const, Copy, Send, Owned};
+import ops::{const, copy, send, owned};
 #[cfg(notest)]
-import ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
+import ops::{add, sub, mul, div, modulo, neg, bitand, bitor, bitxor};
 #[cfg(notest)]
-import ops::{Shl, Shr, Index};
+import ops::{shl, shr, index};
 
 #[cfg(notest)]
-export Const, Copy, Send, Owned;
+export const, copy, send, owned;
 #[cfg(notest)]
-export Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor;
+export add, sub, mul, div, modulo, neg, bitand, bitor, bitxor;
 #[cfg(notest)]
-export Shl, Shr, Index;
+export shl, shr, index;
 
 #[cfg(test)]
 use coreops(name = "core", vers = "0.4");
 
 #[cfg(test)]
-import coreops::ops::{Const, Copy, Send, Owned};
+import coreops::ops::{const, copy, send, owned};
 #[cfg(test)]
-import coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
+import coreops::ops::{add, sub, mul, div, modulo, neg, bitand, bitor, bitxor};
 #[cfg(test)]
-import coreops::ops::{Shl, Shr, Index};
+import coreops::ops::{shl, shr, index};
 
 
 // Export the log levels as global constants. Higher levels mean

branches/incoming/src/libcore/dvec.rs

@@ -327,7 +327,7 @@ impl<A: copy> DVec<A> {
     }
 }
 
-impl<A:copy> DVec<A>: Index<uint,A> {
+impl<A:copy> DVec<A>: index<uint,A> {
     pure fn index(&&idx: uint) -> A {
         self.get_elt(idx)
     }

branches/incoming/src/libcore/extfmt.rs

@@ -1,5 +1,4 @@
 #[doc(hidden)];
-#[allow(non_camel_case_types)];
 
 /*
 Syntax Extension: fmt
@@ -87,7 +86,7 @@ mod ct {
         let mut pieces: ~[piece] = ~[];
         let lim = str::len(s);
         let mut buf = ~"";
-        fn flush_buf(+buf: ~str, &pieces: ~[piece]) -> ~str {
+        fn flush_buf(buf: ~str, &pieces: ~[piece]) -> ~str {
             if str::len(buf) > 0u {
                 let piece = piece_string(buf);
                 vec::push(pieces, piece);
@@ -110,7 +109,7 @@ mod ct {
                 } else {
                     buf = flush_buf(buf, pieces);
                     let rs = parse_conversion(s, i, lim, error);
-                    vec::push(pieces, copy rs.piece);
+                    vec::push(pieces, rs.piece);
                     i = rs.next;
                 }
             } else { buf += curr; i += size; }
@@ -149,7 +148,7 @@ mod ct {
         let ty = parse_type(s, prec.next, lim, error);
         return {piece:
                  piece_conv({param: parm.param,
-                             flags: copy flags.flags,
+                             flags: flags.flags,
                              width: width.count,
                              precision: prec.count,
                              ty: ty.ty}),
@@ -178,12 +177,12 @@ mod ct {
         fn more_(f: flag, s: ~str, i: uint, lim: uint) ->
            {flags: ~[flag], next: uint} {
             let next = parse_flags(s, i + 1u, lim);
-            let rest = copy next.flags;
+            let rest = next.flags;
             let j = next.next;
             let curr: ~[flag] = ~[f];
             return {flags: vec::append(curr, rest), next: j};
         }
-        let more = |x, copy s| more_(x, copy s, i, lim);
+        let more = |x| more_(x, s, i, lim);
         let f = s[i];
         return if f == '-' as u8 {
                 more(flag_left_justify)
@@ -405,14 +404,14 @@ mod rt {
 
     fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {
         let uwidth : uint = match cv.width {
-          count_implied => return copy s,
+          count_implied => return s,
           count_is(width) => {
               // FIXME: width should probably be uint (see Issue #1996)
               width as uint
           }
         };
         let strlen = str::char_len(s);
-        if uwidth <= strlen { return copy s; }
+        if uwidth <= strlen { return s; }
         let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {

branches/incoming/src/libcore/flate.rs

@@ -55,7 +55,6 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {
 }
 
 #[test]
-#[allow(non_implicitly_copyable_typarams)]
 fn test_flate_round_trip() {
     let r = rand::Rng();
     let mut words = ~[];