Removing a lot of usage of '&const'

alexcrichton · alexcrichton · commit b29c36867418 · 2013-06-29T08:35:48.000-07:00
diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
@@ -436,8 +436,8 @@ impl<T:Freeze + Send> 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:Freeze + Send>(state: *const RWARCInner<T>) -> *RWlock {
-    unsafe { cast::transmute(&const (*state).lock) }
+fn borrow_rwlock<T:Freeze + Send>(state: *mut RWARCInner<T>) -> *RWlock {
+    unsafe { cast::transmute(&(*state).lock) }
 }
 
 /// The "write permission" token used for RWARC.write_downgrade().
diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
@@ -705,8 +705,8 @@ impl cmp::Eq for BitvSet {
 }
 
 impl Container for BitvSet {
-    fn len(&const self) -> uint { self.size }
-    fn is_empty(&const self) -> bool { self.size == 0 }
+    fn len(&self) -> uint { self.size }
+    fn is_empty(&self) -> bool { self.size == 0 }
 }
 
 impl Mutable for BitvSet {
diff --git a/src/libextra/deque.rs b/src/libextra/deque.rs
@@ -28,10 +28,10 @@ pub struct Deque<T> {
 
 impl<T> Container for Deque<T> {
     /// Return the number of elements in the deque
-    fn len(&const self) -> uint { self.nelts }
+    fn len(&self) -> uint { self.nelts }
 
     /// Return true if the deque contains no elements
-    fn is_empty(&const self) -> bool { self.len() == 0 }
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<T> Mutable for Deque<T> {
diff --git a/src/libextra/flate.rs b/src/libextra/flate.rs
@@ -44,8 +44,8 @@ static lz_fast : c_int = 0x1;   // LZ with only one probe
 static lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
 static lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
 
-pub fn deflate_bytes(bytes: &const [u8]) -> ~[u8] {
-    do vec::as_const_buf(bytes) |b, len| {
+pub fn deflate_bytes(bytes: &[u8]) -> ~[u8] {
+    do vec::as_imm_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
             let res =
@@ -62,8 +62,8 @@ pub fn deflate_bytes(bytes: &const [u8]) -> ~[u8] {
     }
 }
 
-pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
-    do vec::as_const_buf(bytes) |b, len| {
+pub fn inflate_bytes(bytes: &[u8]) -> ~[u8] {
+    do vec::as_imm_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
             let res =
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
@@ -87,10 +87,10 @@ impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
 
 impl<K: TotalOrd, V> Container for TreeMap<K, V> {
     /// Return the number of elements in the map
-    fn len(&const self) -> uint { self.length }
+    fn len(&self) -> uint { self.length }
 
     /// Return true if the map contains no elements
-    fn is_empty(&const self) -> bool { self.root.is_none() }
+    fn is_empty(&self) -> bool { self.root.is_none() }
 }
 
 impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
@@ -265,11 +265,11 @@ impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
 impl<T: TotalOrd> Container for TreeSet<T> {
     /// Return the number of elements in the set
     #[inline]
-    fn len(&const self) -> uint { self.map.len() }
+    fn len(&self) -> uint { self.map.len() }
 
     /// Return true if the set contains no elements
     #[inline]
-    fn is_empty(&const self) -> bool { self.map.is_empty() }
+    fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl<T: TotalOrd> Mutable for TreeSet<T> {
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
@@ -152,122 +152,122 @@ impl LanguageItems {
 
     // FIXME #4621: Method macros sure would be nice here.
 
-    pub fn freeze_trait(&const self) -> def_id {
+    pub fn freeze_trait(&self) -> def_id {
         self.items[FreezeTraitLangItem as uint].get()
     }
-    pub fn copy_trait(&const self) -> def_id {
+    pub fn copy_trait(&self) -> def_id {
         self.items[CopyTraitLangItem as uint].get()
     }
-    pub fn send_trait(&const self) -> def_id {
+    pub fn send_trait(&self) -> def_id {
         self.items[SendTraitLangItem as uint].get()
     }
-    pub fn sized_trait(&const self) -> def_id {
+    pub fn sized_trait(&self) -> def_id {
         self.items[SizedTraitLangItem as uint].get()
     }
 
-    pub fn drop_trait(&const self) -> def_id {
+    pub fn drop_trait(&self) -> def_id {
         self.items[DropTraitLangItem as uint].get()
     }
 
-    pub fn add_trait(&const self) -> def_id {
+    pub fn add_trait(&self) -> def_id {
         self.items[AddTraitLangItem as uint].get()
     }
-    pub fn sub_trait(&const self) -> def_id {
+    pub fn sub_trait(&self) -> def_id {
         self.items[SubTraitLangItem as uint].get()
     }
-    pub fn mul_trait(&const self) -> def_id {
+    pub fn mul_trait(&self) -> def_id {
         self.items[MulTraitLangItem as uint].get()
     }
-    pub fn div_trait(&const self) -> def_id {
+    pub fn div_trait(&self) -> def_id {
         self.items[DivTraitLangItem as uint].get()
     }
-    pub fn rem_trait(&const self) -> def_id {
+    pub fn rem_trait(&self) -> def_id {
         self.items[RemTraitLangItem as uint].get()
     }
-    pub fn neg_trait(&const self) -> def_id {
+    pub fn neg_trait(&self) -> def_id {
         self.items[NegTraitLangItem as uint].get()
     }
-    pub fn not_trait(&const self) -> def_id {
+    pub fn not_trait(&self) -> def_id {
         self.items[NotTraitLangItem as uint].get()
     }
-    pub fn bitxor_trait(&const self) -> def_id {
+    pub fn bitxor_trait(&self) -> def_id {
         self.items[BitXorTraitLangItem as uint].get()
     }
-    pub fn bitand_trait(&const self) -> def_id {
+    pub fn bitand_trait(&self) -> def_id {
         self.items[BitAndTraitLangItem as uint].get()
     }
-    pub fn bitor_trait(&const self) -> def_id {
+    pub fn bitor_trait(&self) -> def_id {
         self.items[BitOrTraitLangItem as uint].get()
     }
-    pub fn shl_trait(&const self) -> def_id {
+    pub fn shl_trait(&self) -> def_id {
         self.items[ShlTraitLangItem as uint].get()
     }
-    pub fn shr_trait(&const self) -> def_id {
+    pub fn shr_trait(&self) -> def_id {
         self.items[ShrTraitLangItem as uint].get()
     }
-    pub fn index_trait(&const self) -> def_id {
+    pub fn index_trait(&self) -> def_id {
         self.items[IndexTraitLangItem as uint].get()
     }
 
-    pub fn eq_trait(&const self) -> def_id {
+    pub fn eq_trait(&self) -> def_id {
         self.items[EqTraitLangItem as uint].get()
     }
-    pub fn ord_trait(&const self) -> def_id {
+    pub fn ord_trait(&self) -> def_id {
         self.items[OrdTraitLangItem as uint].get()
     }
 
-    pub fn str_eq_fn(&const self) -> def_id {
+    pub fn str_eq_fn(&self) -> def_id {
         self.items[StrEqFnLangItem as uint].get()
     }
-    pub fn uniq_str_eq_fn(&const self) -> def_id {
+    pub fn uniq_str_eq_fn(&self) -> def_id {
         self.items[UniqStrEqFnLangItem as uint].get()
     }
-    pub fn annihilate_fn(&const self) -> def_id {
+    pub fn annihilate_fn(&self) -> def_id {
         self.items[AnnihilateFnLangItem as uint].get()
     }
-    pub fn log_type_fn(&const self) -> def_id {
+    pub fn log_type_fn(&self) -> def_id {
         self.items[LogTypeFnLangItem as uint].get()
     }
-    pub fn fail_fn(&const self) -> def_id {
+    pub fn fail_fn(&self) -> def_id {
         self.items[FailFnLangItem as uint].get()
     }
-    pub fn fail_bounds_check_fn(&const self) -> def_id {
+    pub fn fail_bounds_check_fn(&self) -> def_id {
         self.items[FailBoundsCheckFnLangItem as uint].get()
     }
-    pub fn exchange_malloc_fn(&const self) -> def_id {
+    pub fn exchange_malloc_fn(&self) -> def_id {
         self.items[ExchangeMallocFnLangItem as uint].get()
     }
-    pub fn exchange_free_fn(&const self) -> def_id {
+    pub fn exchange_free_fn(&self) -> def_id {
         self.items[ExchangeFreeFnLangItem as uint].get()
     }
-    pub fn malloc_fn(&const self) -> def_id {
+    pub fn malloc_fn(&self) -> def_id {
         self.items[MallocFnLangItem as uint].get()
     }
-    pub fn free_fn(&const self) -> def_id {
+    pub fn free_fn(&self) -> def_id {
         self.items[FreeFnLangItem as uint].get()
     }
-    pub fn borrow_as_imm_fn(&const self) -> def_id {
+    pub fn borrow_as_imm_fn(&self) -> def_id {
         self.items[BorrowAsImmFnLangItem as uint].get()
     }
-    pub fn borrow_as_mut_fn(&const self) -> def_id {
+    pub fn borrow_as_mut_fn(&self) -> def_id {
         self.items[BorrowAsMutFnLangItem as uint].get()
     }
-    pub fn return_to_mut_fn(&const self) -> def_id {
+    pub fn return_to_mut_fn(&self) -> def_id {
         self.items[ReturnToMutFnLangItem as uint].get()
     }
-    pub fn check_not_borrowed_fn(&const self) -> def_id {
+    pub fn check_not_borrowed_fn(&self) -> def_id {
         self.items[CheckNotBorrowedFnLangItem as uint].get()
     }
-    pub fn strdup_uniq_fn(&const self) -> def_id {
+    pub fn strdup_uniq_fn(&self) -> def_id {
         self.items[StrDupUniqFnLangItem as uint].get()
     }
-    pub fn record_borrow_fn(&const self) -> def_id {
+    pub fn record_borrow_fn(&self) -> def_id {
         self.items[RecordBorrowFnLangItem as uint].get()
     }
-    pub fn unrecord_borrow_fn(&const self) -> def_id {
+    pub fn unrecord_borrow_fn(&self) -> def_id {
         self.items[UnrecordBorrowFnLangItem as uint].get()
     }
-    pub fn start_fn(&const self) -> def_id {
+    pub fn start_fn(&self) -> def_id {
         self.items[StartFnLangItem as uint].get()
     }
     pub fn ty_desc(&const self) -> def_id {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -3696,14 +3696,14 @@ pub enum DtorKind {
 }
 
 impl DtorKind {
-    pub fn is_not_present(&const self) -> bool {
+    pub fn is_not_present(&self) -> bool {
         match *self {
             NoDtor => true,
             _ => false
         }
     }
 
-    pub fn is_present(&const self) -> bool {
+    pub fn is_present(&self) -> bool {
         !self.is_not_present()
     }
 
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
@@ -64,7 +64,7 @@ pub struct VtableContext {
 }
 
 impl VtableContext {
-    pub fn tcx(&const self) -> ty::ctxt { self.ccx.tcx }
+    pub fn tcx(&self) -> ty::ctxt { self.ccx.tcx }
 }
 
 fn has_trait_bounds(type_param_defs: &[ty::TypeParameterDef]) -> bool {
diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
@@ -108,7 +108,7 @@ pub fn build_sized_opt<A>(size: Option<uint>,
 /// Iterates over the `rhs` vector, copying each element and appending it to the
 /// `lhs`. Afterwards, the `lhs` is then returned for use again.
 #[inline]
-pub fn append<T:Copy>(lhs: @[T], rhs: &const [T]) -> @[T] {
+pub fn append<T:Copy>(lhs: @[T], rhs: &[T]) -> @[T] {
     do build_sized(lhs.len() + rhs.len()) |push| {
         for lhs.iter().advance |x| { push(copy *x); }
         for uint::range(0, rhs.len()) |i| { push(copy rhs[i]); }
@@ -180,9 +180,9 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    impl<'self,T:Copy> Add<&'self const [T],@[T]> for @[T] {
+    impl<'self,T:Copy> Add<&'self [T],@[T]> for @[T] {
         #[inline]
-        fn add(&self, rhs: & &'self const [T]) -> @[T] {
+        fn add(&self, rhs: & &'self [T]) -> @[T] {
             append(*self, (*rhs))
         }
     }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
@@ -282,10 +282,10 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
 
 impl<K:Hash + Eq,V> Container for HashMap<K, V> {
     /// Return the number of elements in the map
-    fn len(&const self) -> uint { self.size }
+    fn len(&self) -> uint { self.size }
 
     /// Return true if the map contains no elements
-    fn is_empty(&const self) -> bool { self.len() == 0 }
+    fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
 impl<K:Hash + Eq,V> Mutable for HashMap<K, V> {
@@ -623,10 +623,10 @@ impl<T:Hash + Eq> Eq for HashSet<T> {
 
 impl<T:Hash + Eq> Container for HashSet<T> {
     /// Return the number of elements in the set
-    fn len(&const self) -> uint { self.map.len() }
+    fn len(&self) -> uint { self.map.len() }
 
     /// Return true if the set contains no elements
-    fn is_empty(&const self) -> bool { self.map.is_empty() }
+    fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl<T:Hash + Eq> Mutable for HashSet<T> {
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
@@ -1152,7 +1152,7 @@ impl<W:Writer,C> Writer for Wrapper<W, C> {
 impl Writer for *libc::FILE {
     fn write(&self, v: &[u8]) {
         unsafe {
-            do vec::as_const_buf(v) |vbuf, len| {
+            do vec::as_imm_buf(v) |vbuf, len| {
                 let nout = libc::fwrite(vbuf as *c_void,
                                         1,
                                         len as size_t,
@@ -1203,9 +1203,9 @@ impl Writer for fd_t {
     fn write(&self, v: &[u8]) {
         unsafe {
             let mut count = 0u;
-            do vec::as_const_buf(v) |vbuf, len| {
+            do vec::as_imm_buf(v) |vbuf, len| {
                 while count < len {
-                    let vb = ptr::const_offset(vbuf, count) as *c_void;
+                    let vb = ptr::offset(vbuf, count) as *c_void;
                     let nout = libc::write(*self, vb, len as size_t);
                     if nout < 0 as ssize_t {
                         error!("error writing buffer");
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
@@ -121,13 +121,13 @@ impl<T> Option<T> {
 
     /// Returns true if the option equals `none`
     #[inline]
-    pub fn is_none(&const self) -> bool {
+    pub fn is_none(&self) -> bool {
         match *self { None => true, Some(_) => false }
     }
 
     /// Returns true if the option contains some value
     #[inline]
-    pub fn is_some(&const self) -> bool { !self.is_none() }
+    pub fn is_some(&self) -> bool { !self.is_none() }
 
     /// Update an optional value by optionally running its content through a
     /// function that returns an option.
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs

Original file line number	Diff line number	Diff line change
`@@ -705,8 +705,8 @@ impl cmp::Eq for BitvSet {`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`impl Container for BitvSet {`
`708`		`- fn len(&const self) -> uint { self.size }`
`709`		`- fn is_empty(&const self) -> bool { self.size == 0 }`
	`708`	`+ fn len(&self) -> uint { self.size }`
	`709`	`+ fn is_empty(&self) -> bool { self.size == 0 }`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`impl Mutable for BitvSet {`
Original file line number	Diff line number	Diff line change
`@@ -152,122 +152,122 @@ impl LanguageItems {`
`152`	`152`
`153`	`153`	`// FIXME #4621: Method macros sure would be nice here.`
`154`	`154`
`155`		`- pub fn freeze_trait(&const self) -> def_id {`
	`155`	`+ pub fn freeze_trait(&self) -> def_id {`
`156`	`156`	`self.items[FreezeTraitLangItem as uint].get()`
`157`	`157`	`}`
`158`		`- pub fn copy_trait(&const self) -> def_id {`
	`158`	`+ pub fn copy_trait(&self) -> def_id {`
`159`	`159`	`self.items[CopyTraitLangItem as uint].get()`
`160`	`160`	`}`
`161`		`- pub fn send_trait(&const self) -> def_id {`
	`161`	`+ pub fn send_trait(&self) -> def_id {`
`162`	`162`	`self.items[SendTraitLangItem as uint].get()`
`163`	`163`	`}`
`164`		`- pub fn sized_trait(&const self) -> def_id {`
	`164`	`+ pub fn sized_trait(&self) -> def_id {`
`165`	`165`	`self.items[SizedTraitLangItem as uint].get()`
`166`	`166`	`}`
`167`	`167`
`168`		`- pub fn drop_trait(&const self) -> def_id {`
	`168`	`+ pub fn drop_trait(&self) -> def_id {`
`169`	`169`	`self.items[DropTraitLangItem as uint].get()`
`170`	`170`	`}`
`171`	`171`
`172`		`- pub fn add_trait(&const self) -> def_id {`
	`172`	`+ pub fn add_trait(&self) -> def_id {`
`173`	`173`	`self.items[AddTraitLangItem as uint].get()`
`174`	`174`	`}`
`175`		`- pub fn sub_trait(&const self) -> def_id {`
	`175`	`+ pub fn sub_trait(&self) -> def_id {`
`176`	`176`	`self.items[SubTraitLangItem as uint].get()`
`177`	`177`	`}`
`178`		`- pub fn mul_trait(&const self) -> def_id {`
	`178`	`+ pub fn mul_trait(&self) -> def_id {`
`179`	`179`	`self.items[MulTraitLangItem as uint].get()`
`180`	`180`	`}`
`181`		`- pub fn div_trait(&const self) -> def_id {`
	`181`	`+ pub fn div_trait(&self) -> def_id {`
`182`	`182`	`self.items[DivTraitLangItem as uint].get()`
`183`	`183`	`}`
`184`		`- pub fn rem_trait(&const self) -> def_id {`
	`184`	`+ pub fn rem_trait(&self) -> def_id {`
`185`	`185`	`self.items[RemTraitLangItem as uint].get()`
`186`	`186`	`}`
`187`		`- pub fn neg_trait(&const self) -> def_id {`
	`187`	`+ pub fn neg_trait(&self) -> def_id {`
`188`	`188`	`self.items[NegTraitLangItem as uint].get()`
`189`	`189`	`}`
`190`		`- pub fn not_trait(&const self) -> def_id {`
	`190`	`+ pub fn not_trait(&self) -> def_id {`
`191`	`191`	`self.items[NotTraitLangItem as uint].get()`
`192`	`192`	`}`
`193`		`- pub fn bitxor_trait(&const self) -> def_id {`
	`193`	`+ pub fn bitxor_trait(&self) -> def_id {`
`194`	`194`	`self.items[BitXorTraitLangItem as uint].get()`
`195`	`195`	`}`
`196`		`- pub fn bitand_trait(&const self) -> def_id {`
	`196`	`+ pub fn bitand_trait(&self) -> def_id {`
`197`	`197`	`self.items[BitAndTraitLangItem as uint].get()`
`198`	`198`	`}`
`199`		`- pub fn bitor_trait(&const self) -> def_id {`
	`199`	`+ pub fn bitor_trait(&self) -> def_id {`
`200`	`200`	`self.items[BitOrTraitLangItem as uint].get()`
`201`	`201`	`}`
`202`		`- pub fn shl_trait(&const self) -> def_id {`
	`202`	`+ pub fn shl_trait(&self) -> def_id {`
`203`	`203`	`self.items[ShlTraitLangItem as uint].get()`
`204`	`204`	`}`
`205`		`- pub fn shr_trait(&const self) -> def_id {`
	`205`	`+ pub fn shr_trait(&self) -> def_id {`
`206`	`206`	`self.items[ShrTraitLangItem as uint].get()`
`207`	`207`	`}`
`208`		`- pub fn index_trait(&const self) -> def_id {`
	`208`	`+ pub fn index_trait(&self) -> def_id {`
`209`	`209`	`self.items[IndexTraitLangItem as uint].get()`
`210`	`210`	`}`
`211`	`211`
`212`		`- pub fn eq_trait(&const self) -> def_id {`
	`212`	`+ pub fn eq_trait(&self) -> def_id {`
`213`	`213`	`self.items[EqTraitLangItem as uint].get()`
`214`	`214`	`}`
`215`		`- pub fn ord_trait(&const self) -> def_id {`
	`215`	`+ pub fn ord_trait(&self) -> def_id {`
`216`	`216`	`self.items[OrdTraitLangItem as uint].get()`
`217`	`217`	`}`
`218`	`218`
`219`		`- pub fn str_eq_fn(&const self) -> def_id {`
	`219`	`+ pub fn str_eq_fn(&self) -> def_id {`
`220`	`220`	`self.items[StrEqFnLangItem as uint].get()`
`221`	`221`	`}`
`222`		`- pub fn uniq_str_eq_fn(&const self) -> def_id {`
	`222`	`+ pub fn uniq_str_eq_fn(&self) -> def_id {`
`223`	`223`	`self.items[UniqStrEqFnLangItem as uint].get()`
`224`	`224`	`}`
`225`		`- pub fn annihilate_fn(&const self) -> def_id {`
	`225`	`+ pub fn annihilate_fn(&self) -> def_id {`
`226`	`226`	`self.items[AnnihilateFnLangItem as uint].get()`
`227`	`227`	`}`
`228`		`- pub fn log_type_fn(&const self) -> def_id {`
	`228`	`+ pub fn log_type_fn(&self) -> def_id {`
`229`	`229`	`self.items[LogTypeFnLangItem as uint].get()`
`230`	`230`	`}`
`231`		`- pub fn fail_fn(&const self) -> def_id {`
	`231`	`+ pub fn fail_fn(&self) -> def_id {`
`232`	`232`	`self.items[FailFnLangItem as uint].get()`
`233`	`233`	`}`
`234`		`- pub fn fail_bounds_check_fn(&const self) -> def_id {`
	`234`	`+ pub fn fail_bounds_check_fn(&self) -> def_id {`
`235`	`235`	`self.items[FailBoundsCheckFnLangItem as uint].get()`
`236`	`236`	`}`
`237`		`- pub fn exchange_malloc_fn(&const self) -> def_id {`
	`237`	`+ pub fn exchange_malloc_fn(&self) -> def_id {`
`238`	`238`	`self.items[ExchangeMallocFnLangItem as uint].get()`
`239`	`239`	`}`
`240`		`- pub fn exchange_free_fn(&const self) -> def_id {`
	`240`	`+ pub fn exchange_free_fn(&self) -> def_id {`
`241`	`241`	`self.items[ExchangeFreeFnLangItem as uint].get()`
`242`	`242`	`}`
`243`		`- pub fn malloc_fn(&const self) -> def_id {`
	`243`	`+ pub fn malloc_fn(&self) -> def_id {`
`244`	`244`	`self.items[MallocFnLangItem as uint].get()`
`245`	`245`	`}`
`246`		`- pub fn free_fn(&const self) -> def_id {`
	`246`	`+ pub fn free_fn(&self) -> def_id {`
`247`	`247`	`self.items[FreeFnLangItem as uint].get()`
`248`	`248`	`}`
`249`		`- pub fn borrow_as_imm_fn(&const self) -> def_id {`
	`249`	`+ pub fn borrow_as_imm_fn(&self) -> def_id {`
`250`	`250`	`self.items[BorrowAsImmFnLangItem as uint].get()`
`251`	`251`	`}`
`252`		`- pub fn borrow_as_mut_fn(&const self) -> def_id {`
	`252`	`+ pub fn borrow_as_mut_fn(&self) -> def_id {`
`253`	`253`	`self.items[BorrowAsMutFnLangItem as uint].get()`
`254`	`254`	`}`
`255`		`- pub fn return_to_mut_fn(&const self) -> def_id {`
	`255`	`+ pub fn return_to_mut_fn(&self) -> def_id {`
`256`	`256`	`self.items[ReturnToMutFnLangItem as uint].get()`
`257`	`257`	`}`
`258`		`- pub fn check_not_borrowed_fn(&const self) -> def_id {`
	`258`	`+ pub fn check_not_borrowed_fn(&self) -> def_id {`
`259`	`259`	`self.items[CheckNotBorrowedFnLangItem as uint].get()`
`260`	`260`	`}`
`261`		`- pub fn strdup_uniq_fn(&const self) -> def_id {`
	`261`	`+ pub fn strdup_uniq_fn(&self) -> def_id {`
`262`	`262`	`self.items[StrDupUniqFnLangItem as uint].get()`
`263`	`263`	`}`
`264`		`- pub fn record_borrow_fn(&const self) -> def_id {`
	`264`	`+ pub fn record_borrow_fn(&self) -> def_id {`
`265`	`265`	`self.items[RecordBorrowFnLangItem as uint].get()`
`266`	`266`	`}`
`267`		`- pub fn unrecord_borrow_fn(&const self) -> def_id {`
	`267`	`+ pub fn unrecord_borrow_fn(&self) -> def_id {`
`268`	`268`	`self.items[UnrecordBorrowFnLangItem as uint].get()`
`269`	`269`	`}`
`270`		`- pub fn start_fn(&const self) -> def_id {`
	`270`	`+ pub fn start_fn(&self) -> def_id {`
`271`	`271`	`self.items[StartFnLangItem as uint].get()`
`272`	`272`	`}`
`273`	`273`	`pub fn ty_desc(&const self) -> def_id {`
Original file line number	Diff line number	Diff line change
`@@ -3696,14 +3696,14 @@ pub enum DtorKind {`
`3696`	`3696`	`}`
`3697`	`3697`
`3698`	`3698`	`impl DtorKind {`
`3699`		`- pub fn is_not_present(&const self) -> bool {`
	`3699`	`+ pub fn is_not_present(&self) -> bool {`
`3700`	`3700`	`match *self {`
`3701`	`3701`	`NoDtor => true,`
`3702`	`3702`	`_ => false`
`3703`	`3703`	`}`
`3704`	`3704`	`}`
`3705`	`3705`
`3706`		`- pub fn is_present(&const self) -> bool {`
	`3706`	`+ pub fn is_present(&self) -> bool {`
`3707`	`3707`	`!self.is_not_present()`
`3708`	`3708`	`}`
`3709`	`3709`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ pub struct VtableContext {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`impl VtableContext {`
`67`		`- pub fn tcx(&const self) -> ty::ctxt { self.ccx.tcx }`
	`67`	`+ pub fn tcx(&self) -> ty::ctxt { self.ccx.tcx }`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`fn has_trait_bounds(type_param_defs: &[ty::TypeParameterDef]) -> bool {`