Warning police.

Author: jdm

ast.rs

@@ -95,7 +95,7 @@ pub struct AtRule {
 pub enum DeclarationListItem {
     Declaration(Declaration),
     // A better idea for a name that means "at-rule" but is not "AtRule"?
-    Decl_AtRule(AtRule),
+    DeclAtRule(AtRule),
 }
 
 #[deriving(Eq)]

nth.rs

@@ -23,7 +23,7 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 match unit {
                     "n" => parse_b(iter, a as i32),
                     "n-" => parse_signless_b(iter, a as i32, -1),
-                    _ => match(parse_n_dash_digits(unit)) {
+                    _ => match parse_n_dash_digits(unit) {
                         Some(b) => parse_end(iter, a as i32, b),
                         _ => None
                     },
@@ -40,11 +40,11 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 "-n" => parse_b(iter, -1),
                 "n-" => parse_signless_b(iter, 1, -1),
                 "-n-" => parse_signless_b(iter, -1, -1),
-                _ if ident.starts_with("-") => match(parse_n_dash_digits(ident.slice_from(1))) {
+                _ if ident.starts_with("-") => match parse_n_dash_digits(ident.slice_from(1)) {
                     Some(b) => parse_end(iter, -1, b),
                     _ => None
                 },
-                _ =>  match(parse_n_dash_digits(ident)) {
+                _ =>  match parse_n_dash_digits(ident) {
                     Some(b) => parse_end(iter, 1, b),
                     _ => None
                 },
@@ -56,7 +56,7 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 match ident {
                     "n" => parse_b(iter, 1),
                     "n-" => parse_signless_b(iter, 1, -1),
-                    _ => match(parse_n_dash_digits(ident)) {
+                    _ => match parse_n_dash_digits(ident) {
                         Some(b) => parse_end(iter, 1, b),
                         _ => None
                     },

parser.rs

@@ -160,7 +160,7 @@ for DeclarationListParser<T> {
             match component_value {
                 WhiteSpace | Semicolon => (),
                 AtKeyword(name)
-                => return Some(Ok(Decl_AtRule(parse_at_rule(iter, name, location)))),
+                => return Some(Ok(DeclAtRule(parse_at_rule(iter, name, location)))),
                 _ => return Some(match parse_declaration(iter, component_value, location) {
                     Ok(declaration) => Ok(Declaration(declaration)),
                     Err(e) => {

tokenizer.rs

@@ -185,9 +185,8 @@ fn next_component_value(tokenizer: &mut Tokenizer) -> Option<Node> {
             }
         },
         '.' => {
-            if (
-                tokenizer.position + 1 < tokenizer.length
-                && is_match!(tokenizer.char_at(1), '0'..'9')
+            if tokenizer.position + 1 < tokenizer.length
+                && is_match!(tokenizer.char_at(1), '0'..'9'
             ) {
                 consume_numeric(tokenizer)
             } else {