librustc: Rename Const to Freeze

Author: pcwalton

src/libextra/arc.rs

@@ -113,15 +113,15 @@ impl<'self> Condvar<'self> {
 pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
-pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
+pub fn ARC<T:Freeze + Owned>(data: T) -> ARC<T> {
     ARC { x: UnsafeAtomicRcBox::new(data) }
 }
 
 /**
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-impl<T:Const+Owned> ARC<T> {
+impl<T:Freeze+Owned> ARC<T> {
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
@@ -134,7 +134,7 @@ impl<T:Const+Owned> ARC<T> {
  * object. However, one of the `arc` objects can be sent to another task,
  * allowing them to share the underlying data.
  */
-impl<T:Const + Owned> Clone for ARC<T> {
+impl<T:Freeze + Owned> Clone for ARC<T> {
     fn clone(&self) -> ARC<T> {
         ARC { x: self.x.clone() }
     }
@@ -286,14 +286,14 @@ struct RWARC<T> {
 }
 
 /// Create a reader/writer ARC with the supplied data.
-pub fn RWARC<T:Const + Owned>(user_data: T) -> RWARC<T> {
+pub fn RWARC<T:Freeze + Owned>(user_data: T) -> RWARC<T> {
     rw_arc_with_condvars(user_data, 1)
 }
 /**
  * Create a reader/writer ARC with the supplied data and a specified number
  * of condvars (as sync::rwlock_with_condvars).
  */
-pub fn rw_arc_with_condvars<T:Const + Owned>(
+pub fn rw_arc_with_condvars<T:Freeze + Owned>(
     user_data: T,
     num_condvars: uint) -> RWARC<T>
 {
@@ -303,7 +303,7 @@ pub fn rw_arc_with_condvars<T:Const + Owned>(
     RWARC { x: UnsafeAtomicRcBox::new(data), cant_nest: () }
 }
 
-impl<T:Const + Owned> RWARC<T> {
+impl<T:Freeze + Owned> RWARC<T> {
     /// Duplicate a rwlock-protected ARC, as arc::clone.
     pub fn clone(&self) -> RWARC<T> {
         RWARC {
@@ -314,7 +314,7 @@ impl<T:Const + Owned> RWARC<T> {
 
 }
 
-impl<T:Const + Owned> RWARC<T> {
+impl<T:Freeze + Owned> RWARC<T> {
     /**
      * Access the underlying data mutably. Locks the rwlock in write mode;
      * other readers and writers will block.
@@ -440,7 +440,7 @@ impl<T:Const + Owned> RWARC<T> {
 // lock it. This wraps the unsafety, with the justification that the 'lock'
 // field is never overwritten; only 'failed' and 'data'.
 #[doc(hidden)]
-fn borrow_rwlock<T:Const + Owned>(state: *const RWARCInner<T>) -> *RWlock {
+fn borrow_rwlock<T:Freeze + Owned>(state: *const RWARCInner<T>) -> *RWlock {
     unsafe { cast::transmute(&const (*state).lock) }
 }
 
@@ -457,7 +457,7 @@ pub struct RWReadMode<'self, T> {
     token: sync::RWlockReadMode<'self>,
 }
 
-impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
+impl<'self, T:Freeze + Owned> RWWriteMode<'self, T> {
     /// Access the pre-downgrade RWARC in write mode.
     pub fn write<U>(&mut self, blk: &fn(x: &mut T) -> U) -> U {
         match *self {
@@ -498,7 +498,7 @@ impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
     }
 }
 
-impl<'self, T:Const + Owned> RWReadMode<'self, T> {
+impl<'self, T:Freeze + Owned> RWReadMode<'self, T> {
     /// Access the post-downgrade rwlock in read mode.
     pub fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
         match *self {

src/libextra/rc.rs

@@ -13,10 +13,10 @@
 /** Task-local reference counted smart pointers
 
 Task-local reference counted smart pointers are an alternative to managed boxes with deterministic
-destruction. They are restricted to containing types that are either `Owned` or `Const` (or both) to
+destruction. They are restricted to containing types that are either `Owned` or `Freeze` (or both) to
 prevent cycles.
 
-Neither `Rc<T>` or `RcMut<T>` is ever `Owned` and `RcMut<T>` is never `Const`. If `T` is `Const`, a
+Neither `Rc<T>` or `RcMut<T>` is ever `Owned` and `RcMut<T>` is never `Freeze`. If `T` is `Freeze`, a
 cycle cannot be created with `Rc<T>` because there is no way to modify it after creation.
 
 */
@@ -56,7 +56,7 @@ pub fn rc_from_owned<T: Owned>(value: T) -> Rc<T> {
 }
 
 // FIXME: #6516: should be a static method
-pub fn rc_from_const<T: Const>(value: T) -> Rc<T> {
+pub fn rc_from_const<T: Freeze>(value: T) -> Rc<T> {
     unsafe { Rc::new(value) }
 }
 
@@ -187,7 +187,7 @@ pub fn rc_mut_from_owned<T: Owned>(value: T) -> RcMut<T> {
 }
 
 // FIXME: #6516: should be a static method
-pub fn rc_mut_from_const<T: Const>(value: T) -> RcMut<T> {
+pub fn rc_mut_from_const<T: Freeze>(value: T) -> RcMut<T> {
     unsafe { RcMut::new(value) }
 }
 

src/librustc/metadata/decoder.rs

@@ -96,7 +96,7 @@ fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
 
 #[deriving(Eq)]
 enum Family {
-    Const,                 // c
+    Freeze,                 // c
     Fn,                    // f
     UnsafeFn,              // u
     PureFn,                // p
@@ -121,7 +121,7 @@ enum Family {
 fn item_family(item: ebml::Doc) -> Family {
     let fam = reader::get_doc(item, tag_items_data_item_family);
     match reader::doc_as_u8(fam) as char {
-      'c' => Const,
+      'c' => Freeze,
       'f' => Fn,
       'u' => UnsafeFn,
       'p' => PureFn,
@@ -324,7 +324,7 @@ fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
     -> def_like {
     let fam = item_family(item);
     match fam {
-        Const     => dl_def(ast::def_const(did)),
+        Freeze     => dl_def(ast::def_const(did)),
         Struct    => dl_def(ast::def_struct(did)),
         UnsafeFn  => dl_def(ast::def_fn(did, ast::unsafe_fn)),
         Fn        => dl_def(ast::def_fn(did, ast::impure_fn)),
@@ -951,7 +951,7 @@ pub fn get_item_visibility(cdata: cmd, id: ast::node_id)
 
 fn family_has_type_params(fam: Family) -> bool {
     match fam {
-      Const | ForeignType | Mod | ForeignMod | PublicField | PrivateField
+      Freeze | ForeignType | Mod | ForeignMod | PublicField | PrivateField
       | ForeignFn => false,
       _           => true
     }
@@ -981,7 +981,7 @@ fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
 
 fn item_family_to_str(fam: Family) -> ~str {
     match fam {
-      Const => ~"const",
+      Freeze => ~"const",
       Fn => ~"fn",
       UnsafeFn => ~"unsafe fn",
       PureFn => ~"pure fn",

src/librustc/middle/borrowck/doc.rs

@@ -539,14 +539,14 @@ mutable borrowed pointers.
 
 ### Restrictions for loans of const aliasable pointees
 
-Const pointers are read-only. There may be `&mut` or `&` aliases, and
+Freeze pointers are read-only. There may be `&mut` or `&` aliases, and
 we can not prevent *anything* but moves in that case. So the
 `RESTRICTIONS` function is only defined if `ACTIONS` is the empty set.
 Because moves from a `&const` or `@const` lvalue are never legal, it
 is not necessary to add any restrictions at all to the final
 result.
 
-    RESTRICTIONS(*LV, []) = []                         // R-Deref-Const-Borrowed
+    RESTRICTIONS(*LV, []) = []                         // R-Deref-Freeze-Borrowed
       TYPE(LV) = &const Ty or @const Ty
 
 ### Restrictions for loans of mutable borrowed pointees

src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -125,7 +125,7 @@ impl RestrictionsContext {
 
             mc::cat_deref(_, _, mc::region_ptr(m_const, _)) |
             mc::cat_deref(_, _, mc::gc_ptr(m_const)) => {
-                // R-Deref-Const-Borrowed
+                // R-Deref-Freeze-Borrowed
                 self.check_no_mutability_control(cmt, restrictions);
                 Safe
             }

src/librustc/middle/typeck/collect.rs

@@ -1204,7 +1204,7 @@ pub fn ty_generics(ccx: &CrateCtxt,
          * enum consisting of a newtyped Ty or a region) to ty's
          * notion of ty param bounds, which can either be user-defined
          * traits, or one of the four built-in traits (formerly known
-         * as kinds): Const, Copy, and Send.
+         * as kinds): Freeze, Copy, and Send.
          */
 
         let mut param_bounds = ty::ParamBounds {

src/librustdoc/markdown_pass.rs

@@ -152,7 +152,7 @@ pub fn header_kind(doc: doc::ItemTag) -> ~str {
             ~"Function"
         }
         doc::ConstTag(_) => {
-            ~"Const"
+            ~"Freeze"
         }
         doc::EnumTag(_) => {
             ~"Enum"
@@ -795,7 +795,7 @@ mod test {
     #[test]
     fn should_write_const_header() {
         let markdown = render(~"static a: bool = true;");
-        assert!(str::contains(markdown, "## Const `a`\n\n"));
+        assert!(str::contains(markdown, "## Freeze `a`\n\n"));
     }
 
     #[test]

src/libstd/clone.rs

@@ -22,7 +22,7 @@ by convention implementing the `Clone` trait and calling the
 
 */
 
-use core::kinds::Const;
+use core::kinds::Freeze;
 
 /// A common trait for cloning an object.
 pub trait Clone {
@@ -101,16 +101,16 @@ impl<T: DeepClone> DeepClone for ~T {
 }
 
 // FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
-impl<T: Const + DeepClone> DeepClone for @T {
-    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
+impl<T: Freeze + DeepClone> DeepClone for @T {
+    /// Return a deep copy of the managed box. The `Freeze` trait is required to prevent performing
     /// a deep clone of a potentially cyclical type.
     #[inline(always)]
     fn deep_clone(&self) -> @T { @(**self).deep_clone() }
 }
 
 // FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
-impl<T: Const + DeepClone> DeepClone for @mut T {
-    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
+impl<T: Freeze + DeepClone> DeepClone for @mut T {
+    /// Return a deep copy of the managed box. The `Freeze` trait is required to prevent performing
     /// a deep clone of a potentially cyclical type.
     #[inline(always)]
     fn deep_clone(&self) -> @mut T { @mut (**self).deep_clone() }

src/libstd/kinds.rs

@@ -57,13 +57,13 @@ pub trait Owned {
 
 #[cfg(stage0)]
 #[lang="const"]
-pub trait Const {
+pub trait Freeze {
     // empty.
 }
 
 #[cfg(not(stage0))]
 #[lang="freeze"]
-pub trait Const {
+pub trait Freeze {
     // empty.
 }
 

src/libstd/prelude.rs

@@ -30,7 +30,7 @@ Rust's prelude has three main parts:
 // Reexported core operators
 pub use either::{Either, Left, Right};
 pub use kinds::{Copy, Sized};
-pub use kinds::{Const, Owned};
+pub use kinds::{Freeze, Owned};
 pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Drop};

src/libsyntax/ast.rs

@@ -147,7 +147,7 @@ pub static crate_node_id: node_id = 0;
 // The AST represents all type param bounds as types.
 // typeck::collect::compute_bounds matches these against
 // the "special" built-in traits (see middle::lang_items) and
-// detects Copy, Send, Owned, and Const.
+// detects Copy, Send, Owned, and Freeze.
 pub enum TyParamBound {
     TraitTyParamBound(@trait_ref),
     RegionTyParamBound

src/libsyntax/parse/parser.rs

@@ -1139,14 +1139,14 @@ impl Parser {
 
     pub fn token_is_mutability(&self, tok: &token::Token) -> bool {
         token::is_keyword(keywords::Mut, tok) ||
-        token::is_keyword(keywords::Const, tok)
+        token::is_keyword(keywords::Freeze, tok)
     }
 
     // parse mutability declaration (mut/const/imm)
     pub fn parse_mutability(&self) -> mutability {
         if self.eat_keyword(keywords::Mut) {
             m_mutbl
-        } else if self.eat_keyword(keywords::Const) {
+        } else if self.eat_keyword(keywords::Freeze) {
             m_const
         } else {
             m_imm
@@ -3032,7 +3032,7 @@ impl Parser {
         ) -> ast::explicit_self_ {
             // We need to make sure it isn't a mode or a type
             if token::is_keyword(keywords::Self, &p.look_ahead(1)) ||
-                ((token::is_keyword(keywords::Const, &p.look_ahead(1)) ||
+                ((token::is_keyword(keywords::Freeze, &p.look_ahead(1)) ||
                   token::is_keyword(keywords::Mut, &p.look_ahead(1))) &&
                  token::is_keyword(keywords::Self, &p.look_ahead(2))) {
 
@@ -3667,7 +3667,7 @@ impl Parser {
         let lo = self.span.lo;
 
         // XXX: Obsolete; remove after snap.
-        if self.eat_keyword(keywords::Const) {
+        if self.eat_keyword(keywords::Freeze) {
             self.obsolete(*self.last_span, ObsoleteConstItem);
         } else {
             self.expect_keyword(keywords::Static);
@@ -4058,11 +4058,11 @@ impl Parser {
             }
         }
         // the rest are all guaranteed to be items:
-        if (self.is_keyword(keywords::Const) ||
+        if (self.is_keyword(keywords::Freeze) ||
             (self.is_keyword(keywords::Static) &&
              !token::is_keyword(keywords::Fn, &self.look_ahead(1)))) {
             // CONST / STATIC ITEM
-            if self.is_keyword(keywords::Const) {
+            if self.is_keyword(keywords::Freeze) {
                 self.obsolete(*self.span, ObsoleteConstItem);
             }
             self.bump();
@@ -4160,7 +4160,7 @@ impl Parser {
 
         let visibility = self.parse_visibility();
 
-        if (self.is_keyword(keywords::Const) || self.is_keyword(keywords::Static)) {
+        if (self.is_keyword(keywords::Freeze) || self.is_keyword(keywords::Static)) {
             // FOREIGN CONST ITEM
             let item = self.parse_item_foreign_const(visibility, attrs);
             return iovi_foreign_item(item);

src/libsyntax/parse/token.rs

@@ -549,7 +549,7 @@ pub mod keywords {
         // Strict keywords
         As,
         Break,
-        Const,
+        Freeze,
         Copy,
         Do,
         Else,
@@ -592,7 +592,7 @@ pub mod keywords {
             match *self {
                 As => ident { repr: 35, ctxt: 0 },
                    Break => ident { repr: 36, ctxt: 0 },
-                   Const => ident { repr: 37, ctxt: 0 },
+                   Freeze => ident { repr: 37, ctxt: 0 },
                    Copy => ident { repr: 38, ctxt: 0 },
                    Do => ident { repr: 39, ctxt: 0 },
                    Else => ident { repr: 41, ctxt: 0 },

src/libsyntax/util/interner.rs

@@ -27,7 +27,7 @@ pub struct Interner<T> {
 }
 
 // when traits can extend traits, we should extend index<uint,T> to get []
-impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> {
+impl<T:Eq + IterBytes + Hash + Freeze + Copy> Interner<T> {
     pub fn new() -> Interner<T> {
         Interner {
             map: @mut HashMap::new(),

src/test/auxiliary/issue-2526.rs

@@ -20,17 +20,17 @@ struct arc_destruct<T> {
 }
 
 #[unsafe_destructor]
-impl<T:Const> Drop for arc_destruct<T> {
+impl<T:Freeze> Drop for arc_destruct<T> {
     fn finalize(&self) {}
 }
 
-fn arc_destruct<T:Const>(data: int) -> arc_destruct<T> {
+fn arc_destruct<T:Freeze>(data: int) -> arc_destruct<T> {
     arc_destruct {
         _data: data
     }
 }
 
-fn arc<T:Const>(_data: T) -> arc_destruct<T> {
+fn arc<T:Freeze>(_data: T) -> arc_destruct<T> {
     arc_destruct(0)
 }
 

src/test/compile-fail/issue-2611-4.rs

@@ -20,7 +20,7 @@ struct E {
 }
 
 impl A for E {
-  fn b<F:Copy + Const,G>(_x: F) -> F { fail!() } //~ ERROR type parameter 0 requires `Const`
+  fn b<F:Copy + Freeze,G>(_x: F) -> F { fail!() } //~ ERROR type parameter 0 requires `Freeze`
 }
 
 fn main() {}