auto merge of #8974 : thestinger/rust/char, r=huonw

Closes #7609

Author: bors

src/etc/unicode.py

@@ -158,6 +158,7 @@ def emit_property_module(f, mod, tbl):
     keys.sort()
     emit_bsearch_range_table(f);
     for cat in keys:
+        if cat == "Cs": continue
         f.write("    static %s_table : &'static [(char,char)] = &[\n" % cat)
         ix = 0
         for pair in tbl[cat]:

src/libextra/ebml.rs

@@ -10,7 +10,6 @@
 
 #[allow(missing_doc)];
 
-
 use std::str;
 
 // Simple Extensible Binary Markup Language (ebml) reader and writer on a
@@ -90,6 +89,7 @@ pub enum EbmlEncoderTag {
 // --------------------------------------
 
 pub mod reader {
+    use std::char;
     use super::*;
 
     use serialize;
@@ -426,7 +426,7 @@ pub mod reader {
             (unsafe { transmute::<u64, f64>(bits) }) as float
         }
         fn read_char(&mut self) -> char {
-            doc_as_u32(self.next_doc(EsChar)) as char
+            char::from_u32(doc_as_u32(self.next_doc(EsChar))).unwrap()
         }
         fn read_str(&mut self) -> ~str {
             self.next_doc(EsStr).as_str()

src/libextra/json.rs

@@ -16,6 +16,8 @@
 
 //! json parsing and serialization
 
+use std::char;
+use std::cast::transmute;
 use std::iterator;
 use std::float;
 use std::hashmap::HashMap;
@@ -490,7 +492,7 @@ pub struct Parser<T> {
 pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
     let mut p = Parser {
         rdr: rdr,
-        ch: 0 as char,
+        ch: '\x00',
         line: 1,
         col: 0,
     };
@@ -517,12 +519,13 @@ impl<T: iterator::Iterator<char>> Parser<T> {
 }
 
 impl<T : iterator::Iterator<char>> Parser<T> {
-    fn eof(&self) -> bool { self.ch == -1 as char }
+    // FIXME: #8971: unsound
+    fn eof(&self) -> bool { self.ch == unsafe { transmute(-1u32) } }
 
     fn bump(&mut self) {
         match self.rdr.next() {
             Some(ch) => self.ch = ch,
-            None() => self.ch = -1 as char,
+            None() => self.ch = unsafe { transmute(-1u32) }, // FIXME: #8971: unsound
         }
 
         if self.ch == '\n' {
@@ -755,7 +758,7 @@ impl<T : iterator::Iterator<char>> Parser<T> {
                             ~"invalid \\u escape (not four digits)");
                       }
 
-                      res.push_char(n as char);
+                      res.push_char(char::from_u32(n as u32).unwrap());
                   }
                   _ => return self.error(~"invalid escape")
                 }

src/libextra/terminfo/parm.rs

@@ -258,7 +258,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                             ' ' => flags.space = true,
                             '.' => fstate = FormatStatePrecision,
                             '0'..'9' => {
-                                flags.width = (cur - '0') as uint;
+                                flags.width = (cur as uint - '0' as uint);
                                 fstate = FormatStateWidth;
                             }
                             _ => util::unreachable()
@@ -330,7 +330,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                         state = Nothing;
                     }
                     '0'..'9' => {
-                        state = IntConstant(i*10 + ((cur - '0') as int));
+                        state = IntConstant(i*10 + (cur as int - '0' as int));
                         old_state = Nothing;
                     }
                     _ => return Err(~"bad int constant")
@@ -358,23 +358,23 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                         flags.space = true;
                     }
                     (FormatStateFlags,'0'..'9') => {
-                        flags.width = (cur - '0') as uint;
+                        flags.width = (cur as uint - '0' as uint);
                         *fstate = FormatStateWidth;
                     }
                     (FormatStateFlags,'.') => {
                         *fstate = FormatStatePrecision;
                     }
                     (FormatStateWidth,'0'..'9') => {
                         let old = flags.width;
-                        flags.width = flags.width * 10 + ((cur - '0') as uint);
+                        flags.width = flags.width * 10 + (cur as uint - '0' as uint);
                         if flags.width < old { return Err(~"format width overflow") }
                     }
                     (FormatStateWidth,'.') => {
                         *fstate = FormatStatePrecision;
                     }
                     (FormatStatePrecision,'0'..'9') => {
                         let old = flags.precision;
-                        flags.precision = flags.precision * 10 + ((cur - '0') as uint);
+                        flags.precision = flags.precision * 10 + (cur as uint - '0' as uint);
                         if flags.precision < old { return Err(~"format precision overflow") }
                     }
                     _ => return Err(~"invalid format specifier")

src/libextra/url.rs

@@ -72,7 +72,7 @@ fn encode_inner(s: &str, full_url: bool) -> ~str {
         let mut out = ~"";
 
         while !rdr.eof() {
-            let ch = rdr.read_byte() as char;
+            let ch = rdr.read_byte() as u8 as char;
             match ch {
               // unreserved:
               'A' .. 'Z' |
@@ -135,7 +135,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str {
             match rdr.read_char() {
               '%' => {
                 let bytes = rdr.read_bytes(2u);
-                let ch = uint::parse_bytes(bytes, 16u).unwrap() as char;
+                let ch = uint::parse_bytes(bytes, 16u).unwrap() as u8 as char;
 
                 if full_url {
                     // Only decode some characters:
@@ -186,7 +186,7 @@ fn encode_plus(s: &str) -> ~str {
         let mut out = ~"";
 
         while !rdr.eof() {
-            let ch = rdr.read_byte() as char;
+            let ch = rdr.read_byte() as u8 as char;
             match ch {
               'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '_' | '.' | '-' => {
                 out.push_char(ch);
@@ -258,7 +258,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> HashMap<~str, ~[~str]> {
                     let ch = match ch {
                         '%' => {
                             let bytes = rdr.read_bytes(2u);
-                            uint::parse_bytes(bytes, 16u).unwrap() as char
+                            uint::parse_bytes(bytes, 16u).unwrap() as u8 as char
                         }
                         '+' => ' ',
                         ch => ch
@@ -295,7 +295,7 @@ fn split_char_first(s: &str, c: char) -> (~str, ~str) {
     do io::with_str_reader(s) |rdr| {
         let mut ch;
         while !rdr.eof() {
-            ch = rdr.read_byte() as char;
+            ch = rdr.read_byte() as u8 as char;
             if ch == c {
                 // found a match, adjust markers
                 index = rdr.tell()-1;

src/librustc/metadata/tyencode.rs

@@ -239,10 +239,10 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, st: &ty::sty) {
       ty::ty_nil => w.write_char('n'),
       ty::ty_bot => w.write_char('z'),
       ty::ty_bool => w.write_char('b'),
+      ty::ty_char => w.write_char('c'),
       ty::ty_int(t) => {
         match t {
           ty_i => w.write_char('i'),
-          ty_char => w.write_char('c'),
           ty_i8 => w.write_str(&"MB"),
           ty_i16 => w.write_str(&"MW"),
           ty_i32 => w.write_str(&"ML"),

src/librustc/middle/check_const.rs

@@ -200,21 +200,19 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
         }
     }
     match e.node {
-      ExprLit(@codemap::Spanned {node: lit_int(v, t), _}) => {
-        if t != ty_char {
+        ExprLit(@codemap::Spanned {node: lit_int(v, t), _}) => {
             if (v as u64) > ast_util::int_ty_max(
                 if t == ty_i { sess.targ_cfg.int_type } else { t }) {
                 sess.span_err(e.span, "literal out of range for its type");
             }
         }
-      }
-      ExprLit(@codemap::Spanned {node: lit_uint(v, t), _}) => {
-        if v > ast_util::uint_ty_max(
-            if t == ty_u { sess.targ_cfg.uint_type } else { t }) {
-            sess.span_err(e.span, "literal out of range for its type");
+        ExprLit(@codemap::Spanned {node: lit_uint(v, t), _}) => {
+            if v > ast_util::uint_ty_max(
+                if t == ty_u { sess.targ_cfg.uint_type } else { t }) {
+                sess.span_err(e.span, "literal out of range for its type");
+            }
         }
-      }
-      _ => ()
+        _ => ()
     }
     visit::walk_expr(v, e, is_const);
 }

src/librustc/middle/const_eval.rs

@@ -472,6 +472,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
 pub fn lit_to_const(lit: &lit) -> const_val {
     match lit.node {
       lit_str(s) => const_str(s),
+      lit_char(n) => const_uint(n as u64),
       lit_int(n, _) => const_int(n),
       lit_uint(n, _) => const_uint(n),
       lit_int_unsuffixed(n) => const_int(n),

src/librustc/middle/lint.rs

@@ -778,7 +778,6 @@ impl TypeLimitsLintVisitor {
     fn int_ty_range(&mut self, int_ty: ast::int_ty) -> (i64, i64) {
         match int_ty {
             ast::ty_i =>    (i64::min_value,        i64::max_value),
-            ast::ty_char => (u32::min_value as i64, u32::max_value as i64),
             ast::ty_i8 =>   (i8::min_value  as i64, i8::max_value  as i64),
             ast::ty_i16 =>  (i16::min_value as i64, i16::max_value as i64),
             ast::ty_i32 =>  (i32::min_value as i64, i32::max_value as i64),

src/librustc/middle/resolve.rs

@@ -777,7 +777,7 @@ pub fn PrimitiveTypeTable() -> PrimitiveTypeTable {
     };
 
     table.intern("bool",    ty_bool);
-    table.intern("char",    ty_int(ty_char));
+    table.intern("char",    ty_char);
     table.intern("float",   ty_float(ty_f));
     table.intern("f32",     ty_float(ty_f32));
     table.intern("f64",     ty_float(ty_f64));