librustc: Remove pure from libsyntax and librustc.

Author: pcwalton

src/librustc/back/rpath.rs

@@ -20,7 +20,7 @@ use core::util;
 use core::vec;
 use core::hashmap::linear::LinearSet;
 
-pure fn not_win32(os: session::os) -> bool {
+fn not_win32(os: session::os) -> bool {
   match os {
       session::os_win32 => false,
       _ => true

src/librustc/metadata/decoder.rs

@@ -872,7 +872,7 @@ pub fn get_item_attrs(cdata: cmd,
     }
 }
 
-pure fn struct_field_family_to_visibility(family: Family) -> ast::visibility {
+fn struct_field_family_to_visibility(family: Family) -> ast::visibility {
     match family {
       PublicField => ast::public,
       PrivateField => ast::private,

src/librustc/middle/borrowck/mod.rs

@@ -444,7 +444,7 @@ pub impl LoanKind {
 /// Creates and returns a new root_map
 
 impl to_bytes::IterBytes for root_map_key {
-    pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
+    fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);
     }
 }

src/librustc/middle/lint.rs

@@ -534,7 +534,7 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
 }
 
 fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
-    pure fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T,
+    fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T,
             min: T, max: T) -> bool {
         match binop {
             ast::lt => v <= max,
@@ -546,7 +546,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
         }
     }
 
-    pure fn rev_binop(binop: ast::binop) -> ast::binop {
+    fn rev_binop(binop: ast::binop) -> ast::binop {
         match binop {
             ast::lt => ast::gt,
             ast::le => ast::ge,
@@ -556,7 +556,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
         }
     }
 
-    pure fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) {
+    fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) {
         match int_ty {
             ast::ty_i =>    (int::min_value as i64, int::max_value as i64),
             ast::ty_char => (u32::min_value as i64, u32::max_value as i64),
@@ -567,7 +567,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
         }
     }
 
-    pure fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) {
+    fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) {
         match uint_ty {
             ast::ty_u =>   (uint::min_value as u64, uint::max_value as u64),
             ast::ty_u8 =>  (u8::min_value   as u64, u8::max_value   as u64),
@@ -622,7 +622,7 @@ fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
         }
     }
 
-    pure fn is_comparison(binop: ast::binop) -> bool {
+    fn is_comparison(binop: ast::binop) -> bool {
         match binop {
             ast::eq | ast::lt | ast::le |
             ast::ne | ast::ge | ast::gt => true,

src/librustc/middle/liveness.rs

@@ -141,13 +141,13 @@ struct Variable(uint);
 struct LiveNode(uint);
 
 impl cmp::Eq for Variable {
-    pure fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) }
-    pure fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) }
+    fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) }
+    fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) }
 }
 
 impl cmp::Eq for LiveNode {
-    pure fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) }
-    pure fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) }
+    fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) }
+    fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) }
 }
 
 enum LiveNodeKind {
@@ -158,7 +158,7 @@ enum LiveNodeKind {
 }
 
 impl cmp::Eq for LiveNodeKind {
-    pure fn eq(&self, other: &LiveNodeKind) -> bool {
+    fn eq(&self, other: &LiveNodeKind) -> bool {
         match (*self) {
             FreeVarNode(e0a) => {
                 match (*other) {
@@ -186,7 +186,7 @@ impl cmp::Eq for LiveNodeKind {
             }
         }
     }
-    pure fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) }
+    fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) }
 }
 
 fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
@@ -224,11 +224,11 @@ pub fn check_crate(tcx: ty::ctxt,
 }
 
 impl to_str::ToStr for LiveNode {
-    pure fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) }
+    fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) }
 }
 
 impl to_str::ToStr for Variable {
-    pure fn to_str(&self) -> ~str { fmt!("v(%u)", **self) }
+    fn to_str(&self) -> ~str { fmt!("v(%u)", **self) }
 }
 
 // ______________________________________________________________________
@@ -254,7 +254,7 @@ impl to_str::ToStr for Variable {
 // assignment.  And so forth.
 
 pub impl LiveNode {
-    pure fn is_valid(&self) -> bool { **self != uint::max_value }
+    fn is_valid(&self) -> bool { **self != uint::max_value }
 }
 
 fn invalid_node() -> LiveNode { LiveNode(uint::max_value) }

src/librustc/middle/mem_categorization.rs

@@ -305,7 +305,7 @@ pub struct mem_categorization_ctxt {
 }
 
 impl ToStr for MutabilityCategory {
-    pure fn to_str(&self) -> ~str {
+    fn to_str(&self) -> ~str {
         fmt!("%?", *self)
     }
 }

src/librustc/middle/resolve.rs

@@ -151,7 +151,7 @@ pub enum NamespaceResult {
 }
 
 pub impl NamespaceResult {
-    pure fn is_unknown(&self) -> bool {
+    fn is_unknown(&self) -> bool {
         match *self {
             UnknownResult => true,
             _ => false

src/librustc/middle/trans/cabi_x86_64.rs

@@ -41,10 +41,10 @@ enum x86_64_reg_class {
 }
 
 impl cmp::Eq for x86_64_reg_class {
-    pure fn eq(&self, other: &x86_64_reg_class) -> bool {
+    fn eq(&self, other: &x86_64_reg_class) -> bool {
         ((*self) as uint) == ((*other) as uint)
     }
-    pure fn ne(&self, other: &x86_64_reg_class) -> bool { !(*self).eq(other) }
+    fn ne(&self, other: &x86_64_reg_class) -> bool { !(*self).eq(other) }
 }
 
 fn is_sse(++c: x86_64_reg_class) -> bool {

src/librustc/middle/trans/common.rs

@@ -678,9 +678,9 @@ pub fn block_parent(cx: block) -> block {
 // Accessors
 
 pub impl block_ {
-    pure fn ccx(@mut self) -> @CrateContext { *self.fcx.ccx }
-    pure fn tcx(@mut self) -> ty::ctxt { self.fcx.ccx.tcx }
-    pure fn sess(@mut self) -> Session { self.fcx.ccx.sess }
+    fn ccx(@mut self) -> @CrateContext { *self.fcx.ccx }
+    fn tcx(@mut self) -> ty::ctxt { self.fcx.ccx.tcx }
+    fn sess(@mut self) -> Session { self.fcx.ccx.sess }
 
     fn node_id_to_str(@mut self, id: ast::node_id) -> ~str {
         ast_map::node_id_to_str(self.tcx().items, id, self.sess().intr())
@@ -1290,7 +1290,7 @@ pub struct mono_id_ {
 pub type mono_id = @mono_id_;
 
 impl to_bytes::IterBytes for mono_param_id {
-    pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
+    fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
             mono_precise(t, ref mids) =>
                 to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), mids, lsb0, f),
@@ -1304,7 +1304,7 @@ impl to_bytes::IterBytes for mono_param_id {
 }
 
 impl to_bytes::IterBytes for mono_id_ {
-    pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
+    fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);
     }
 }

src/librustc/middle/trans/datum.rs

@@ -158,14 +158,14 @@ pub impl DatumMode {
 }
 
 impl cmp::Eq for DatumMode {
-    pure fn eq(&self, other: &DatumMode) -> bool {
+    fn eq(&self, other: &DatumMode) -> bool {
         (*self) as uint == (*other as uint)
     }
-    pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) }
+    fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) }
 }
 
 impl to_bytes::IterBytes for DatumMode {
-    pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
+    fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f)
     }
 }