Upgrade to rustc 0a4c136d6 2014-09-23

Author: SimonSapin

src/ast.rs

@@ -32,7 +32,7 @@ pub enum ComponentValue {
     AtKeyword(String),
     Hash(String),
     IDHash(String),  // Hash that is a valid ID selector.
-    String(String),
+    QuotedString(String),
     URL(String),
     Delim(char),
     Number(NumericValue),
@@ -107,15 +107,15 @@ pub struct AtRule {
 
 #[deriving(PartialEq)]
 pub enum DeclarationListItem {
-    Declaration(Declaration),
+    Declaration_(Declaration),
     // A better idea for a name that means "at-rule" but is not "AtRule"?
     DeclAtRule(AtRule),
 }
 
 #[deriving(PartialEq)]
 pub enum Rule {
-    QualifiedRule(QualifiedRule),
-    AtRule(AtRule),
+    QualifiedRule_(QualifiedRule),
+    AtRule_(AtRule),
 }
 
 #[deriving(PartialEq)]
@@ -172,7 +172,7 @@ pub trait MoveSkipWhitespaceIterable {
 
 impl MoveSkipWhitespaceIterable for Vec<ComponentValue> {
     fn move_skip_whitespace(self) -> MoveSkipWhitespaceIterator {
-        MoveSkipWhitespaceIterator{ iter_with_whitespace: self.move_iter() }
+        MoveSkipWhitespaceIterator{ iter_with_whitespace: self.into_iter() }
     }
 }
 

src/color.rs

@@ -27,7 +27,7 @@ impl fmt::Show for RGBA {
 #[deriving(Clone, PartialEq)]
 pub enum Color {
     CurrentColor,
-    RGBA(RGBA),
+    RGBAColor(RGBA),
 }
 
 
@@ -199,11 +199,11 @@ fn parse_color_keyword(value: &str) -> Result<Color, ()> {
         "whitesmoke" => (245., 245., 245.),
         "yellowgreen" => (154., 205., 50.),
 
-        "transparent" => return Ok(RGBA(RGBA { red: 0., green: 0., blue: 0., alpha: 0. })),
+        "transparent" => return Ok(RGBAColor(RGBA { red: 0., green: 0., blue: 0., alpha: 0. })),
         "currentcolor" => return Ok(CurrentColor),
         _ => return Err(()),
     };
-    Ok(RGBA(RGBA { red: r / 255., green: g / 255., blue: b / 255., alpha: 1. }))
+    Ok(RGBAColor(RGBA { red: r / 255., green: g / 255., blue: b / 255., alpha: 1. }))
 }
 
 
@@ -222,7 +222,7 @@ fn parse_color_hash(value: &str) -> Result<Color, ()> {
     )
     macro_rules! to_rgba(
         ($r: expr, $g: expr, $b: expr,) => {
-            Ok(RGBA(RGBA { red: $r as f32 / 255.,
+            Ok(RGBAColor(RGBA { red: $r as f32 / 255.,
                            green: $g as f32 / 255.,
                            blue: $b as f32 / 255.,
                            alpha: 1. }))
@@ -336,7 +336,7 @@ fn parse_color_function(name: &str, arguments: &[ComponentValue])
         1.
     };
     if iter.next().is_none() {
-        Ok(RGBA(RGBA { red: red, green: green, blue: blue, alpha: alpha }))
+        Ok(RGBAColor(RGBA { red: red, green: green, blue: blue, alpha: alpha }))
     } else {
         Err(())
     }

src/lib.rs

@@ -23,7 +23,7 @@ pub use parser::{parse_stylesheet_rules, StylesheetParser,
                  parse_declaration_list, DeclarationListParser,
                  parse_one_rule, parse_one_declaration, parse_one_component_value};
 pub use from_bytes::{decode_stylesheet_bytes, parse_stylesheet_rules_from_bytes};
-pub use color::{RGBA, Color, CurrentColor};
+pub use color::{RGBA, Color, CurrentColor, RGBAColor};
 pub use nth::parse_nth;
 pub use serializer::{ToCss, serialize_identifier, serialize_string};
 

src/parser.rs

@@ -119,9 +119,9 @@ impl<T: Iterator<Node>> Iterator<Result<Rule, SyntaxError>> for StylesheetParser
         for_iter!(iter, (component_value, location), {
             match component_value {
                 WhiteSpace | CDO | CDC => (),
-                AtKeyword(name) => return Some(Ok(AtRule(parse_at_rule(iter, name, location)))),
+                AtKeyword(name) => return Some(Ok(AtRule_(parse_at_rule(iter, name, location)))),
                 _ => return Some(match parse_qualified_rule(iter, component_value, location) {
-                    Ok(rule) => Ok(QualifiedRule(rule)),
+                    Ok(rule) => Ok(QualifiedRule_(rule)),
                     Err(e) => Err(e),
                 }),
             }
@@ -137,9 +137,9 @@ impl<T: Iterator<Node>> Iterator<Result<Rule, SyntaxError>> for RuleListParser<T
         for_iter!(iter, (component_value, location), {
             match component_value {
                 WhiteSpace => (),
-                AtKeyword(name) => return Some(Ok(AtRule(parse_at_rule(iter, name, location)))),
+                AtKeyword(name) => return Some(Ok(AtRule_(parse_at_rule(iter, name, location)))),
                 _ => return Some(match parse_qualified_rule(iter, component_value, location) {
-                    Ok(rule) => Ok(QualifiedRule(rule)),
+                    Ok(rule) => Ok(QualifiedRule_(rule)),
                     Err(e) => Err(e),
                 }),
             }
@@ -159,7 +159,7 @@ for DeclarationListParser<T> {
                 AtKeyword(name)
                 => return Some(Ok(DeclAtRule(parse_at_rule(iter, name, location)))),
                 _ => return Some(match parse_declaration(iter, component_value, location) {
-                    Ok(declaration) => Ok(Declaration(declaration)),
+                    Ok(declaration) => Ok(Declaration_(declaration)),
                     Err(e) => {
                         // Find the end of the declaration
                         for (v, _) in *iter { if v == Semicolon { break } }

src/serializer.rs

@@ -22,7 +22,7 @@ pub fn to_css_push(component_value: &ComponentValue, css: &mut String) {
             css.push_char('#');
             serialize_identifier(value.as_slice(), css);
         }
-        String(ref value) => serialize_string(value.as_slice(), css),
+        QuotedString(ref value) => serialize_string(value.as_slice(), css),
         URL(ref value) => {
             css.push_str("url(");
             serialize_string(value.as_slice(), css);

src/tests.rs

@@ -82,7 +82,7 @@ fn run_raw_json_tests(json_data: &str, run: |json::Json, json::Json|) {
     };
     assert!(items.len() % 2 == 0);
     let mut input = None;
-    for item in items.move_iter() {
+    for item in items.into_iter() {
         match (&input, item) {
             (&None, json_obj) => input = Some(json_obj),
             (&Some(_), expected) => {
@@ -189,7 +189,7 @@ fn stylesheet_from_bytes() {
         assert_json_eq(result, expected, json::Object(map).to_string());
     });
 
-    fn get_string<'a>(map: &'a json::Object, key: &String) -> Option<&'a str> {
+    fn get_string<'a>(map: &'a json::JsonObject, key: &String) -> Option<&'a str> {
         match map.find(key) {
             Some(&json::String(ref s)) => Some(s.as_slice()),
             Some(&json::Null) => None,
@@ -227,7 +227,7 @@ fn color3_hsl() {
 fn color3_keywords() {
     run_color_tests(include_str!("css-parsing-tests/color3_keywords.json"), |c| {
         match c {
-            Some(RGBA(RGBA { red: r, green: g, blue: b, alpha: a }))
+            Some(RGBAColor(RGBA { red: r, green: g, blue: b, alpha: a }))
             => vec!(r * 255., g * 255., b * 255., a).to_json(),
             Some(CurrentColor) => JString!("currentColor"),
             None => json::Null,
@@ -329,7 +329,7 @@ impl ToJson for SyntaxError {
 impl ToJson for Color {
     fn to_json(&self) -> json::Json {
         match *self {
-            RGBA(RGBA { red: r, green: g, blue: b, alpha: a }) => vec!(r, g, b, a).to_json(),
+            RGBAColor(RGBA { red: r, green: g, blue: b, alpha: a }) => vec!(r, g, b, a).to_json(),
             CurrentColor => JString!("currentColor"),
         }
     }
@@ -339,8 +339,8 @@ impl ToJson for Color {
 impl ToJson for Rule {
     fn to_json(&self) -> json::Json {
         match *self {
-            QualifiedRule(ref rule) => rule.to_json(),
-            AtRule(ref rule) => rule.to_json(),
+            QualifiedRule_(ref rule) => rule.to_json(),
+            AtRule_(ref rule) => rule.to_json(),
         }
     }
 }
@@ -349,7 +349,7 @@ impl ToJson for Rule {
 impl ToJson for DeclarationListItem {
     fn to_json(&self) -> json::Json {
         match *self {
-            Declaration(ref declaration) => declaration.to_json(),
+            Declaration_(ref declaration) => declaration.to_json(),
             DeclAtRule(ref at_rule) => at_rule.to_json(),
         }
     }
@@ -414,7 +414,7 @@ impl ToJson for ComponentValue {
             Hash(ref value) => JList!(JString!("hash"), value.to_json(),
                                       JString!("unrestricted")),
             IDHash(ref value) => JList!(JString!("hash"), value.to_json(), JString!("id")),
-            String(ref value) => JList!(JString!("string"), value.to_json()),
+            QuotedString(ref value) => JList!(JString!("string"), value.to_json()),
             URL(ref value) => JList!(JString!("url"), value.to_json()),
             Delim('\\') => JString!("\\"),
             Delim(value) => json::String(String::from_char(1, value)),

src/tokenizer.rs

@@ -307,7 +307,7 @@ fn consume_block_with_location(tokenizer: &mut Tokenizer, ending_token: Componen
 
 fn consume_string(tokenizer: &mut Tokenizer, single_quote: bool) -> ComponentValue {
     match consume_quoted_string(tokenizer, single_quote) {
-        Ok(value) => String(value),
+        Ok(value) => QuotedString(value),
         Err(()) => BadString
     }
 }