Update to Rust 0.8-pre~54c8c23

Author: SimonSapin

ast.rs

@@ -2,6 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::str::ToStr;
+
 
 #[deriving(Eq)]
 pub struct NumericValue {
@@ -108,3 +110,7 @@ pub enum ErrorReason {
     ErrInvalidBangImportantSyntax,
     // This is meant to be extended
 }
+
+impl ToStr for ErrorReason {
+    fn to_str(&self) -> ~str { fmt!("%?", self) }
+}

cssparser.rc

@@ -28,7 +28,7 @@ static CFG_TEST: bool = true;
 pub fn eq_ascii_lower(string: &str, reference: &str) -> bool {
     #[inline]
     fn eq(string: &str, reference: &str) -> bool {
-        for std::uint::range(0, string.len()) |i| {
+        for i in range(0, string.len()) {
             if ASCII_LOWER_MAP[string[i]] != reference[i] {
                 return false
             }
@@ -47,7 +47,7 @@ pub fn eq_ascii_lower(string: &str, reference: &str) -> bool {
 /// A-Z is replaced by a-z, non-ASCII letters are unchanged.
 pub fn to_ascii_lower(string: &str) -> ~str {
     let mut lower = string.to_owned();
-    for std::uint::range(0, lower.len()) |i| {
+    for i in range(0, lower.len()) {
         lower[i] = ASCII_LOWER_MAP[lower[i]];
     }
     lower
@@ -62,7 +62,7 @@ fn test_ascii_lower() {
     assert!(eq_ascii_lower("HİKß", "hİKß"));
     assert!(to_ascii_lower("HİKß") == ~"hİKß");
 
-    for std::uint::range(0, 128) |i| {
+    for i in range(0, 128) {
         let c = i as char;
         let lower = if 'A' <= c && c <= 'Z' { c + 'a' - 'A' } else { c };
         assert!(ASCII_LOWER_MAP[i] as char == lower)

parser.rs

@@ -21,7 +21,7 @@ use super::eq_ascii_lower;
 // TODO: Use a trait?
 enum ComponentValueIterator {
     ParserIter(~Parser),
-    VectorIter(vec::VecConsumeIterator<(ComponentValue, SourceLocation)>),
+    VectorIter(vec::ConsumeIterator<(ComponentValue, SourceLocation)>),
 }
 
 
@@ -43,7 +43,7 @@ impl ComponentValueIterator {
 
     #[inline]
     pub fn next_non_whitespace(&mut self) -> Option<(ComponentValue, SourceLocation)> {
-        for self.advance |(component_value, location)| {
+        for (component_value, location) in *self {
             if component_value != WhiteSpace { return Some((component_value, location)) }
         }
         None
@@ -127,7 +127,7 @@ pub fn parse_declaration_or_at_rule(iter: &mut ComponentValueIterator)
                 Ok(declaration) => Ok(Declaration(declaration)),
                 Err(reason) => {
                     // Find the end of the declaration
-                    for iter.advance |(v, _)| { if v == Semicolon { break } }
+                    for (v, _) in *iter { if v == Semicolon { break } }
                     Err(reason)
                 }
             }),

tests.rs

@@ -36,8 +36,8 @@ fn almost_equals(a: &json::Json, b: &json::Json) -> bool {
 
 fn assert_json_eq(results: json::Json, expected: json::Json, message: ~str) {
     if !almost_equals(&results, &expected) {
-        let temp = tempfile::mkdtemp(&os::tmpdir(), "rust-cssparser-tests").get();
-        let temp_ = copy temp;
+        let temp = tempfile::mkdtemp(&os::tmpdir(), "rust-cssparser-tests").unwrap();
+        let temp_ = temp.clone();
         let results = json::to_pretty_str(&results) + "\n";
         let expected = json::to_pretty_str(&expected) + "\n";
         do task::try {
@@ -62,11 +62,11 @@ fn run_json_tests(json_data: &str, parse: &fn (input: ~str) -> json::Json) {
     };
     assert!(items.len() % 2 == 0);
     let mut input: Option<~str> = None;
-    for items.consume_iter().advance |item| {
+    for item in items.consume_iter() {
         match (&input, item) {
             (&None, json::String(string)) => input = Some(string),
             (&Some(_), expected) => {
-                let input = input.swap_unwrap();
+                let input = input.take_unwrap();
                 let result = parse(input.to_owned());
                 assert_json_eq(result, expected, input);
             },

tokenizer.rs

@@ -429,9 +429,9 @@ fn consume_numeric(parser: &mut Parser) -> ComponentValue {
                 i64::from_str(representation)
             } else {
                 i64::from_str(representation.slice_from(1))
-            }.get()
+            }.unwrap()
         )} else { None },
-        value: f64::from_str(representation).get(),
+        value: f64::from_str(representation).unwrap(),
         representation: representation,
     };
     if !parser.is_eof() && parser.current_char() == '%' {
@@ -599,5 +599,5 @@ fn consume_escape(parser: &mut Parser) -> char {
 
 #[inline]
 fn char_from_hex(hex: &str) -> char {
-    u32::from_str_radix(hex, 16).get() as char
+    u32::from_str_radix(hex, 16).unwrap() as char
 }