Increase precedence of as operator

Closes #1717

5 files changed, 36 insertions, 38 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 19cf97624ab..e825314e2da 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -19,22 +19,22 @@ type doc = {data: @[u8], start: uint, end: uint};
 
 fn vint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
     let a = data[start];
-    if a & 0x80u8 != 0u8 { ret {val: a & 0x7fu8 as uint, next: start + 1u}; }
+    if a & 0x80u8 != 0u8 {
+        ret {val: (a & 0x7fu8) as uint, next: start + 1u};
+    }
     if a & 0x40u8 != 0u8 {
-        ret {val: (a & 0x3fu8 as uint) << 8u | (data[start + 1u] as uint),
+        ret {val: ((a & 0x3fu8) as uint) << 8u | (data[start + 1u] as uint),
              next: start + 2u};
     } else if a & 0x20u8 != 0u8 {
-        ret {val:
-                 (a & 0x1fu8 as uint) << 16u |
-                     (data[start + 1u] as uint) << 8u |
-                     (data[start + 2u] as uint),
+        ret {val: ((a & 0x1fu8) as uint) << 16u |
+                 (data[start + 1u] as uint) << 8u |
+                 (data[start + 2u] as uint),
              next: start + 3u};
     } else if a & 0x10u8 != 0u8 {
-        ret {val:
-                 (a & 0x0fu8 as uint) << 24u |
-                     (data[start + 1u] as uint) << 16u |
-                     (data[start + 2u] as uint) << 8u |
-                     (data[start + 3u] as uint),
+        ret {val: ((a & 0x0fu8) as uint) << 24u |
+                 (data[start + 1u] as uint) << 16u |
+                 (data[start + 2u] as uint) << 8u |
+                 (data[start + 3u] as uint),
              next: start + 4u};
     } else { #error("vint too big"); fail; }
 }
@@ -122,16 +122,14 @@ fn write_sized_vint(w: io::writer, n: uint, size: uint) {
     let buf: [u8];
     alt size {
       1u { buf = [0x80u8 | (n as u8)]; }
-      2u { buf = [0x40u8 | (n >> 8u as u8), n & 0xffu as u8]; }
+      2u { buf = [0x40u8 | ((n >> 8u) as u8), (n & 0xffu) as u8]; }
       3u {
-        buf =
-            [0x20u8 | (n >> 16u as u8), n >> 8u & 0xffu as u8,
-             n & 0xffu as u8];
+        buf = [0x20u8 | ((n >> 16u) as u8), (n >> 8u & 0xffu) as u8,
+               (n & 0xffu) as u8];
       }
       4u {
-        buf =
-            [0x10u8 | (n >> 24u as u8), n >> 16u & 0xffu as u8,
-             n >> 8u & 0xffu as u8, n & 0xffu as u8];
+        buf = [0x10u8 | ((n >> 24u) as u8), (n >> 16u & 0xffu) as u8,
+               (n >> 8u & 0xffu) as u8, (n & 0xffu) as u8];
       }
       _ { #error("vint to write too big"); fail; }
     }
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 239b8768858..2304445b95b 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -70,8 +70,8 @@ fn basename(p: path) -> path unsafe {
         if i == -1 { ret p; }
     }
     let len = str::byte_len(p);
-    if i + 1 as uint >= len { ret p; }
-    ret str::unsafe::slice_bytes(p, i + 1 as uint, len);
+    if (i + 1) as uint >= len { ret p; }
+    ret str::unsafe::slice_bytes(p, (i + 1) as uint, len);
 }
 
 
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 8f77a804892..95f275a9be0 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -59,10 +59,10 @@ impl reader_util for reader {
                     assert (next > -1);
                     assert (next & 192 == 128);
                     val <<= 6u;
-                    val += next & 63 as uint;
+                    val += (next & 63) as uint;
                 }
                 // See str::char_at
-                val += (b0 << (w + 1u as u8) as uint)
+                val += ((b0 << ((w + 1u) as u8)) as uint)
                     << (w - 1u) * 6u - w - 1u;
                 chars += [ val as char ];
             }
@@ -368,14 +368,14 @@ fn mk_file_writer(path: str, flags: [fileflag])
 
 fn uint_to_le_bytes(n: uint, size: uint) -> [u8] {
     let bytes: [u8] = [], i = size, n = n;
-    while i > 0u { bytes += [n & 255u as u8]; n >>= 8u; i -= 1u; }
+    while i > 0u { bytes += [(n & 255u) as u8]; n >>= 8u; i -= 1u; }
     ret bytes;
 }
 
 fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
     let bytes: [u8] = [];
-    let i = size - 1u as int;
-    while i >= 0 { bytes += [n >> (i * 8 as uint) & 255u as u8]; i -= 1; }
+    let i = (size - 1u) as int;
+    while i >= 0 { bytes += [(n >> ((i * 8) as uint) & 255u) as u8]; i -= 1; }
     ret bytes;
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 8da3d78552d..8d3bbac1ce4 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -296,7 +296,7 @@ mod chained {
 
         fn insert(k: K, v: V) -> bool {
             let nchains = vec::len(self.chains);
-            let load = {num: self.size + 1u as int, den: nchains as int};
+            let load = {num: (self.size + 1u) as int, den: nchains as int};
             // Structural consts would be nice. This is a const 3/4
             // load factor that we compare against.
             if !util::rational_leq(load, {num:3, den:4}) { rehash(self); }
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index a9911d01f03..242bf61db13 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -193,10 +193,10 @@ fn mk_sha1() -> sha1 {
         if !st.computed { pad_msg(st); st.computed = true; }
         let rs: [u8] = [];
         for hpart: u32 in st.h {
-            let a = hpart >> 24u32 & 0xFFu32 as u8;
-            let b = hpart >> 16u32 & 0xFFu32 as u8;
-            let c = hpart >> 8u32 & 0xFFu32 as u8;
-            let d = hpart & 0xFFu32 as u8;
+            let a = (hpart >> 24u32 & 0xFFu32) as u8;
+            let b = (hpart >> 16u32 & 0xFFu32) as u8;
+            let c = (hpart >> 8u32 & 0xFFu32) as u8;
+            let d = (hpart & 0xFFu32) as u8;
             rs += [a, b, c, d];
         }
         ret rs;
@@ -238,14 +238,14 @@ fn mk_sha1() -> sha1 {
         }
 
         // Store the message length as the last 8 octets
-        st.msg_block[56] = st.len_high >> 24u32 & 0xFFu32 as u8;
-        st.msg_block[57] = st.len_high >> 16u32 & 0xFFu32 as u8;
-        st.msg_block[58] = st.len_high >> 8u32 & 0xFFu32 as u8;
-        st.msg_block[59] = st.len_high & 0xFFu32 as u8;
-        st.msg_block[60] = st.len_low >> 24u32 & 0xFFu32 as u8;
-        st.msg_block[61] = st.len_low >> 16u32 & 0xFFu32 as u8;
-        st.msg_block[62] = st.len_low >> 8u32 & 0xFFu32 as u8;
-        st.msg_block[63] = st.len_low & 0xFFu32 as u8;
+        st.msg_block[56] = (st.len_high >> 24u32 & 0xFFu32) as u8;
+        st.msg_block[57] = (st.len_high >> 16u32 & 0xFFu32) as u8;
+        st.msg_block[58] = (st.len_high >> 8u32 & 0xFFu32) as u8;
+        st.msg_block[59] = (st.len_high & 0xFFu32) as u8;
+        st.msg_block[60] = (st.len_low >> 24u32 & 0xFFu32) as u8;
+        st.msg_block[61] = (st.len_low >> 16u32 & 0xFFu32) as u8;
+        st.msg_block[62] = (st.len_low >> 8u32 & 0xFFu32) as u8;
+        st.msg_block[63] = (st.len_low & 0xFFu32) as u8;
         process_msg_block(st);
     }