---

yaml
---
r: 52047
b: refs/heads/dist-snap
c: 5ec3aba
h: refs/heads/master
i:
  52045: d30696f
  52043: 5a202a9
  52039: 4cf72aa
  52031: bd24528
v: v3

Author: steveklabnik

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: fa5ee934edecff9c3fa82ade705bd964dc734525
+refs/heads/dist-snap: 5ec3aba8cc977f5b396a8e2636bd0ddbbfa9af66
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/CONTRIBUTING.md

@@ -1107,19 +1107,6 @@ let mut a: Animal = Dog;
 a = Cat;
 ~~~~
 
-Enumeration constructors can have either named or unnamed fields:
-~~~~
-enum Animal {
-    Dog (~str, float),
-    Cat { name: ~str, weight: float }
-}
-
-let mut a: Animal = Dog(~"Cocoa", 37.2);
-a = Cat{ name: ~"Spotty", weight: 2.7 };
-~~~~
-
-In this example, `Cat` is a _struct-like enum variant_,
-whereas `Dog` is simply called an enum variant.
 ### Constants
 
 ~~~~~~~~ {.ebnf .gram}

branches/dist-snap/doc/rust.md

@@ -733,24 +733,6 @@ fn point_from_direction(dir: Direction) -> Point {
 }
 ~~~~
 
-A special kind of enum variant, called _struct-like enums_,
-can have its fields extracted with dot notation and not just destructuring.
-For example:
-
-~~~~
-# struct Point {x: float, y: float}
-# fn square(x: float) -> float { x * x }
-enum Shape {
-    Circle { center: Point, radius: float },
-    Rectangle { left: Point, right: Point }
-}
-fn area(sh: Shape) -> float {
-   match sh {
-      Circle(c) => float::consts::pi * square(c.radius),
-      Rectangle(r) => r.right.x - r.left.x * r.right.y - r.right.y
-   }
-}
-~~~~
 ## Tuples
 
 Tuples in Rust behave exactly like structs, except that their fields

branches/dist-snap/doc/tutorial.md

@@ -12,18 +12,18 @@
 extern mod core(vers = "0.6");
 
 #[cfg(cargo)]
-extern mod this(name = "cargo", vers = "0.6");
+extern mod self(name = "cargo", vers = "0.6");
 
 #[cfg(fuzzer)]
-extern mod this(name = "fuzzer", vers = "0.6");
+extern mod self(name = "fuzzer", vers = "0.6");
 
 #[cfg(rustdoc)]
-extern mod this(name = "rustdoc", vers = "0.6");
+extern mod self(name = "rustdoc", vers = "0.6");
 
 #[cfg(rusti)]
-extern mod this(name = "rusti", vers = "0.6");
+extern mod self(name = "rusti", vers = "0.6");
 
 #[cfg(rustc)]
-extern mod this(name = "rustc", vers = "0.6");
+extern mod self(name = "rustc", vers = "0.6");
 
-fn main() { this::main() }
+fn main() { self::main() }

branches/dist-snap/src/driver/driver.rs

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Dec 25
+" Last Change:  2012 Dec 14
 
 if version < 600
   syntax clear
@@ -44,8 +44,8 @@ syn keyword   rustType        off_t dev_t ino_t pid_t mode_t ssize_t
 
 syn keyword   rustTrait       Const Copy Send Owned " inherent traits
 syn keyword   rustTrait       Eq Ord Num Ptr
-syn keyword   rustTrait       Drop Add Sub Mul Div Modulo Neg BitAnd BitOr
-syn keyword   rustTrait       BitXor Shl Shr Index
+syn keyword   rustTrait       Add Sub Mul Div Modulo Neg BitAnd BitOr BitXor
+syn keyword   rustTrait       Shl Shr Index
 
 syn keyword   rustSelf        self
 syn keyword   rustBoolean     true false

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::os;
-use core::run;
-
 fn gpgv(args: ~[~str]) -> { status: int, out: ~str, err: ~str } {
     return run::program_output(~"gpgv", args);
 }

branches/dist-snap/src/libcargo/pgp.rs

@@ -15,26 +15,21 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
-use iter;
-use libc;
 use ptr::addr_of;
-use sys;
-use uint;
-use vec;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
 
 #[abi = "cdecl"]
-pub extern mod rustrt {
+extern mod rustrt {
     #[legacy_exports];
     fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
                                  ++v: **vec::raw::VecRepr,
                                  ++n: libc::size_t);
 }
 
 #[abi = "rust-intrinsic"]
-pub extern mod rusti {
+extern mod rusti {
     #[legacy_exports];
     fn move_val_init<T>(dst: &mut T, -src: T);
 }
@@ -162,13 +157,6 @@ pub mod traits {
 pub mod traits {}
 
 pub mod raw {
-    use at_vec::{rusti, rustrt};
-    use libc;
-    use ptr;
-    use sys;
-    use uint;
-    use vec;
-
     pub type VecRepr = vec::raw::VecRepr;
     pub type SliceRepr = vec::raw::SliceRepr;
 

branches/dist-snap/src/libcore/at_vec.rs

@@ -16,8 +16,6 @@
 
 //! Boolean logic
 
-use bool;
-use cmp;
 use cmp::Eq;
 
 /// Negation / inverse

branches/dist-snap/src/libcore/bool.rs

@@ -14,12 +14,7 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use char;
 use cmp::Eq;
-use str;
-use u32;
-use uint;
-use unicode;
 
 /*
     Lu  Uppercase_Letter    an uppercase letter

branches/dist-snap/src/libcore/char.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use task;
-
 // helper for transmutation, shown below.
 type RustClosure = (int,int);
 pub struct Handler<T, U> {

branches/dist-snap/src/libcore/condition.rs

@@ -235,7 +235,7 @@ mod stackwalk;
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
 #[doc(hidden)] // FIXME #3538
-pub mod core {
+mod core {
     pub const error : u32 = 1_u32;
     pub const warn : u32 = 2_u32;
     pub const info : u32 = 3_u32;

branches/dist-snap/src/libcore/core.rc

@@ -22,10 +22,6 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use managed;
-use option;
-use vec;
-
 type DListLink<T> = Option<DListNode<T>>;
 
 enum DListNode<T> = @{
@@ -473,10 +469,6 @@ impl<T: Copy> DList<T> {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
-
-    use iter;
-    use vec;
-
     #[test]
     fn test_dlist_concat() {
         let a = from_vec(~[1,2]);

branches/dist-snap/src/libcore/dlist.rs

@@ -23,10 +23,8 @@ Note that recursive use is not permitted.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use cast;
 use cast::reinterpret_cast;
 use ptr::null;
-use vec;
 
 /**
  * A growable, modifiable vector type that accumulates elements into a

branches/dist-snap/src/libcore/dvec.rs

@@ -14,11 +14,8 @@
 
 //! A type that represents one of two alternatives
 
-use cmp;
 use cmp::Eq;
-use result;
 use result::Result;
-use vec;
 
 /// The either type
 #[deriving_eq]

branches/dist-snap/src/libcore/either.rs

@@ -82,7 +82,7 @@ debug!("hello, %s!", "world");
 
 use cmp::Eq;
 use option::{Some, None};
-use str;
+
 
 /*
  * We have a 'ct' (compile-time) module that parses format strings into a
@@ -98,10 +98,6 @@ use str;
 // Functions used by the fmt extension at compile time
 #[doc(hidden)]
 pub mod ct {
-    use char;
-    use str;
-    use vec;
-
     pub enum Signedness { Signed, Unsigned, }
     pub enum Caseness { CaseUpper, CaseLower, }
     pub enum Ty {
@@ -336,12 +332,6 @@ pub mod ct {
 // implement it 0this way, I think.
 #[doc(hidden)]
 pub mod rt {
-    use float;
-    use str;
-    use sys;
-    use uint;
-    use vec;
-
     pub const flag_none : u32 = 0u32;
     pub const flag_left_justify   : u32 = 0b00000000000001u32;
     pub const flag_left_zero_pad  : u32 = 0b00000000000010u32;

branches/dist-snap/src/libcore/extfmt.rs

@@ -14,9 +14,6 @@
 
 //! Operations and constants for `f32`
 
-use cmp;
-use num;
-
 pub use cmath::c_float_utils::*;
 pub use cmath::c_float_targ_consts::*;
 

branches/dist-snap/src/libcore/f32.rs

@@ -14,11 +14,6 @@
 
 //! Operations and constants for `f64`
 
-use cmath;
-use cmp;
-use libc;
-use num;
-
 pub use cmath::c_double_utils::*;
 pub use cmath::c_double_targ_consts::*;
 

branches/dist-snap/src/libcore/f64.rs

@@ -18,11 +18,7 @@ Simple compression
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use libc;
 use libc::{c_void, size_t, c_int};
-use ptr;
-use rand;
-use vec;
 
 extern mod rustrt {
     fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
@@ -92,8 +88,8 @@ fn test_flate_round_trip() {
         }
         debug!("de/inflate of %u bytes of random word-sequences",
                in.len());
-        let cmp = deflate_bytes(in);
-        let out = inflate_bytes(cmp);
+        let cmp = flate::deflate_bytes(in);
+        let out = flate::inflate_bytes(cmp);
         debug!("%u bytes deflated to %u (%.1f%% size)",
                in.len(), cmp.len(),
                100.0 * ((cmp.len() as float) / (in.len() as float)));

branches/dist-snap/src/libcore/flate.rs

@@ -26,14 +26,6 @@
 
 use m_float = f64;
 
-use cmp::{Eq, Ord};
-use cmp;
-use f64;
-use num;
-use num::Num::from_int;
-use str;
-use uint;
-
 pub use f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
 pub use f64::logarithm;
 pub use f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
@@ -43,6 +35,8 @@ pub use f64::{lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix};
 pub use f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
 pub use f64::signbit;
 pub use f64::{j0, j1, jn, y0, y1, yn};
+use cmp::{Eq, Ord};
+use num::Num::from_int;
 
 pub const NaN: float = 0.0/0.0;
 

branches/dist-snap/src/libcore/float.rs

@@ -39,15 +39,10 @@ with destructors.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use cast;
-use io;
-use libc::{size_t, uintptr_t};
-use ptr;
-use send_map::linear::LinearMap;
-use stackwalk;
-use sys;
-
 pub use stackwalk::Word;
+use libc::size_t;
+use libc::uintptr_t;
+use send_map::linear::LinearMap;
 
 // Mirrors rust_stack.h stk_seg
 struct StackSegment {

branches/dist-snap/src/libcore/gc.rs

@@ -23,12 +23,9 @@
  * CPRNG like rand::rng.
  */
 
-use io;
-use io::{Writer, WriterUtil};
-use os;
+use io::Writer;
+use io::WriterUtil;
 use to_bytes::IterBytes;
-use uint;
-use vec;
 
 /**
  * Types that can meaningfully be hashed should implement this.