---

yaml
---
r: 137690
b: refs/heads/auto
c: ab5935c
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d9874bfb4079876dabc092c035d99b2d5b7f8a1c
+refs/heads/auto: ab5935c88d259d511561ccb4177bb6924dab4a06
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libstd/bitflags.rs

@@ -24,12 +24,12 @@
 /// ```{.rust}
 /// bitflags! {
 ///     flags Flags: u32 {
-///         static FLAG_A       = 0x00000001,
-///         static FLAG_B       = 0x00000010,
-///         static FLAG_C       = 0x00000100,
-///         static FLAG_ABC     = FLAG_A.bits
-///                             | FLAG_B.bits
-///                             | FLAG_C.bits,
+///         const FLAG_A       = 0x00000001,
+///         const FLAG_B       = 0x00000010,
+///         const FLAG_C       = 0x00000100,
+///         const FLAG_ABC     = FLAG_A.bits
+///                            | FLAG_B.bits
+///                            | FLAG_C.bits,
 ///     }
 /// }
 ///
@@ -50,8 +50,8 @@
 ///
 /// bitflags! {
 ///     flags Flags: u32 {
-///         static FLAG_A   = 0x00000001,
-///         static FLAG_B   = 0x00000010,
+///         const FLAG_A   = 0x00000001,
+///         const FLAG_B   = 0x00000010,
 ///     }
 /// }
 ///
@@ -115,15 +115,15 @@
 #[macro_export]
 macro_rules! bitflags {
     ($(#[$attr:meta])* flags $BitFlags:ident: $T:ty {
-        $($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+
+        $($(#[$Flag_attr:meta])* const $Flag:ident = $value:expr),+
     }) => {
         #[deriving(PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
         $(#[$attr])*
         pub struct $BitFlags {
             bits: $T,
         }
 
-        $($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
+        $($(#[$Flag_attr])* pub const $Flag: $BitFlags = $BitFlags { bits: $value };)+
 
         impl $BitFlags {
             /// Returns an empty set of flags.
@@ -235,12 +235,12 @@ macro_rules! bitflags {
         }
     };
     ($(#[$attr:meta])* flags $BitFlags:ident: $T:ty {
-        $($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+,
+        $($(#[$Flag_attr:meta])* const $Flag:ident = $value:expr),+,
     }) => {
         bitflags! {
             $(#[$attr])*
             flags $BitFlags: $T {
-                $($(#[$Flag_attr])* static $Flag = $value),+
+                $($(#[$Flag_attr])* const $Flag = $value),+
             }
         }
     };
@@ -259,22 +259,22 @@ mod tests {
         #[doc = "> "]
         #[doc = "> - Richard Feynman"]
         flags Flags: u32 {
-            static FlagA       = 0x00000001,
+            const FlagA       = 0x00000001,
             #[doc = "<pcwalton> macros are way better at generating code than trans is"]
-            static FlagB       = 0x00000010,
-            static FlagC       = 0x00000100,
+            const FlagB       = 0x00000010,
+            const FlagC       = 0x00000100,
             #[doc = "* cmr bed"]
             #[doc = "* strcat table"]
             #[doc = "<strcat> wait what?"]
-            static FlagABC     = FlagA.bits
+            const FlagABC     = FlagA.bits
                                | FlagB.bits
                                | FlagC.bits,
         }
     }
 
     bitflags! {
         flags AnotherSetOfFlags: uint {
-            static AnotherFlag = 1u,
+            const AnotherFlag = 1u,
         }
     }
 

branches/auto/src/libstd/collections/hashmap/map.rs

@@ -41,8 +41,8 @@ use super::table::{
     SafeHash
 };
 
-static INITIAL_LOG2_CAP: uint = 5;
-pub static INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
+const INITIAL_LOG2_CAP: uint = 5;
+pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
 
 /// The default behavior of HashMap implements a load factor of 90.9%.
 /// This behavior is characterized by the following conditions:

branches/auto/src/libstd/collections/hashmap/table.rs

@@ -24,7 +24,7 @@ use ptr::{RawPtr, copy_nonoverlapping_memory, zero_memory};
 use ptr;
 use rt::heap::{allocate, deallocate};
 
-static EMPTY_BUCKET: u64 = 0u64;
+const EMPTY_BUCKET: u64 = 0u64;
 
 /// The raw hashtable, providing safe-ish access to the unzipped and highly
 /// optimized arrays of hashes, keys, and values.

branches/auto/src/libstd/io/mod.rs

@@ -283,7 +283,7 @@ pub mod util;
 /// The default buffer size for various I/O operations
 // libuv recommends 64k buffers to maximize throughput
 // https://groups.google.com/forum/#!topic/libuv/oQO1HJAIDdA
-static DEFAULT_BUF_SIZE: uint = 1024 * 64;
+const DEFAULT_BUF_SIZE: uint = 1024 * 64;
 
 /// A convenient typedef of the return value of any I/O action.
 pub type IoResult<T> = Result<T, IoError>;
@@ -1803,93 +1803,93 @@ bitflags! {
     #[doc = "A set of permissions for a file or directory is represented"]
     #[doc = "by a set of flags which are or'd together."]
     flags FilePermission: u32 {
-        static USER_READ     = 0o400,
-        static USER_WRITE    = 0o200,
-        static USER_EXECUTE  = 0o100,
-        static GROUP_READ    = 0o040,
-        static GROUP_WRITE   = 0o020,
-        static GROUP_EXECUTE = 0o010,
-        static OTHER_READ    = 0o004,
-        static OTHER_WRITE   = 0o002,
-        static OTHER_EXECUTE = 0o001,
-
-        static USER_RWX  = USER_READ.bits | USER_WRITE.bits | USER_EXECUTE.bits,
-        static GROUP_RWX = GROUP_READ.bits | GROUP_WRITE.bits | GROUP_EXECUTE.bits,
-        static OTHER_RWX = OTHER_READ.bits | OTHER_WRITE.bits | OTHER_EXECUTE.bits,
+        const USER_READ     = 0o400,
+        const USER_WRITE    = 0o200,
+        const USER_EXECUTE  = 0o100,
+        const GROUP_READ    = 0o040,
+        const GROUP_WRITE   = 0o020,
+        const GROUP_EXECUTE = 0o010,
+        const OTHER_READ    = 0o004,
+        const OTHER_WRITE   = 0o002,
+        const OTHER_EXECUTE = 0o001,
+
+        const USER_RWX  = USER_READ.bits | USER_WRITE.bits | USER_EXECUTE.bits,
+        const GROUP_RWX = GROUP_READ.bits | GROUP_WRITE.bits | GROUP_EXECUTE.bits,
+        const OTHER_RWX = OTHER_READ.bits | OTHER_WRITE.bits | OTHER_EXECUTE.bits,
 
         #[doc = "Permissions for user owned files, equivalent to 0644 on"]
         #[doc = "unix-like systems."]
-        static USER_FILE = USER_READ.bits | USER_WRITE.bits | GROUP_READ.bits | OTHER_READ.bits,
+        const USER_FILE = USER_READ.bits | USER_WRITE.bits | GROUP_READ.bits | OTHER_READ.bits,
 
         #[doc = "Permissions for user owned directories, equivalent to 0755 on"]
         #[doc = "unix-like systems."]
-        static USER_DIR  = USER_RWX.bits | GROUP_READ.bits | GROUP_EXECUTE.bits |
+        const USER_DIR  = USER_RWX.bits | GROUP_READ.bits | GROUP_EXECUTE.bits |
                    OTHER_READ.bits | OTHER_EXECUTE.bits,
 
         #[doc = "Permissions for user owned executables, equivalent to 0755"]
         #[doc = "on unix-like systems."]
-        static USER_EXEC = USER_DIR.bits,
+        const USER_EXEC = USER_DIR.bits,
 
         #[doc = "All possible permissions enabled."]
-        static ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits,
+        const ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits,
 
         // Deprecated names
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_READ instead"]
-        static UserRead     = USER_READ.bits,
+        const UserRead     = USER_READ.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_WRITE instead"]
-        static UserWrite    = USER_WRITE.bits,
+        const UserWrite    = USER_WRITE.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_EXECUTE instead"]
-        static UserExecute  = USER_EXECUTE.bits,
+        const UserExecute  = USER_EXECUTE.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use GROUP_READ instead"]
-        static GroupRead    = GROUP_READ.bits,
+        const GroupRead    = GROUP_READ.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use GROUP_WRITE instead"]
-        static GroupWrite   = GROUP_WRITE.bits,
+        const GroupWrite   = GROUP_WRITE.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use GROUP_EXECUTE instead"]
-        static GroupExecute = GROUP_EXECUTE.bits,
+        const GroupExecute = GROUP_EXECUTE.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use OTHER_READ instead"]
-        static OtherRead    = OTHER_READ.bits,
+        const OtherRead    = OTHER_READ.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use OTHER_WRITE instead"]
-        static OtherWrite   = OTHER_WRITE.bits,
+        const OtherWrite   = OTHER_WRITE.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use OTHER_EXECUTE instead"]
-        static OtherExecute = OTHER_EXECUTE.bits,
+        const OtherExecute = OTHER_EXECUTE.bits,
 
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_RWX instead"]
-        static UserRWX  = USER_RWX.bits,
+        const UserRWX  = USER_RWX.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use GROUP_RWX instead"]
-        static GroupRWX = GROUP_RWX.bits,
+        const GroupRWX = GROUP_RWX.bits,
         #[allow(non_uppercase_statics)]
         #[deprecated = "use OTHER_RWX instead"]
-        static OtherRWX = OTHER_RWX.bits,
+        const OtherRWX = OTHER_RWX.bits,
 
         #[doc = "Deprecated: use `USER_FILE` instead."]
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_FILE instead"]
-        static UserFile = USER_FILE.bits,
+        const UserFile = USER_FILE.bits,
 
         #[doc = "Deprecated: use `USER_DIR` instead."]
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_DIR instead"]
-        static UserDir  = USER_DIR.bits,
+        const UserDir  = USER_DIR.bits,
         #[doc = "Deprecated: use `USER_EXEC` instead."]
         #[allow(non_uppercase_statics)]
         #[deprecated = "use USER_EXEC instead"]
-        static UserExec = USER_EXEC.bits,
+        const UserExec = USER_EXEC.bits,
 
         #[doc = "Deprecated: use `ALL_PERMISSIONS` instead"]
         #[allow(non_uppercase_statics)]
         #[deprecated = "use ALL_PERMISSIONS instead"]
-        static AllPermissions = ALL_PERMISSIONS.bits,
+        const AllPermissions = ALL_PERMISSIONS.bits,
     }
 }
 

branches/auto/src/libstd/io/process.rs

@@ -32,16 +32,16 @@ use std::hash::sip::SipState;
 
 /// Signal a process to exit, without forcibly killing it. Corresponds to
 /// SIGTERM on unix platforms.
-#[cfg(windows)] pub static PleaseExitSignal: int = 15;
+#[cfg(windows)] pub const PleaseExitSignal: int = 15;
 /// Signal a process to exit immediately, forcibly killing it. Corresponds to
 /// SIGKILL on unix platforms.
-#[cfg(windows)] pub static MustDieSignal: int = 9;
+#[cfg(windows)] pub const MustDieSignal: int = 9;
 /// Signal a process to exit, without forcibly killing it. Corresponds to
 /// SIGTERM on unix platforms.
-#[cfg(not(windows))] pub static PleaseExitSignal: int = libc::SIGTERM as int;
+#[cfg(not(windows))] pub const PleaseExitSignal: int = libc::SIGTERM as int;
 /// Signal a process to exit immediately, forcibly killing it. Corresponds to
 /// SIGKILL on unix platforms.
-#[cfg(not(windows))] pub static MustDieSignal: int = libc::SIGKILL as int;
+#[cfg(not(windows))] pub const MustDieSignal: int = libc::SIGKILL as int;
 
 /// Representation of a running or exited child process.
 ///