Error wrapping

src/css.rs

@@ -69,12 +69,8 @@ impl Selector {
                     false
                 }
                 SelectorComponent::Element(name) => match &node.data {
-                    Element { name: eltname, .. } => {
-                        if name == eltname.expanded().local.deref() {
-                            Self::do_matches(&comps[1..], node)
-                        } else {
-                            false
-                        }
+                    Element { name: eltname, .. } if name == eltname.expanded().local.deref() => {
+                        Self::do_matches(&comps[1..], node)
                     }
                     _ => false,
                 },
@@ -306,11 +302,11 @@ impl StyleData {
 
     pub(crate) fn computed_style(
         &self,
-        parent_style: &ComputedStyle,
+        parent_style: ComputedStyle,
         handle: &Handle,
         use_doc_css: bool,
     ) -> ComputedStyle {
-        let mut result = *parent_style;
+        let mut result = parent_style;
 
         for (origin, ruleset) in [
             (StyleOrigin::Agent, &self.agent_rules),
@@ -425,9 +421,9 @@ impl StyleData {
     }
 }
 
-fn pending<'a, F>(handle: Handle, f: F) -> TreeMapResult<'a, (), Handle, Vec<String>>
+fn pending<F>(handle: Handle, f: F) -> TreeMapResult<'static, (), Handle, Vec<String>>
 where
-    for<'r> F: Fn(&'r mut (), Vec<Vec<String>>) -> Result<Option<Vec<String>>> + 'static,
+    F: Fn(&mut (), Vec<Vec<String>>) -> Result<Option<Vec<String>>> + 'static,
 {
     TreeMapResult::PendingChildren {
         children: handle.children.borrow().clone(),
@@ -451,10 +447,10 @@ fn combine_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
     }
 }
 
-fn extract_style_nodes<'a, T: Write>(
+fn extract_style_nodes<T: Write>(
     handle: Handle,
     _err_out: &mut T,
-) -> TreeMapResult<'a, (), Handle, Vec<String>> {
+) -> TreeMapResult<'static, (), Handle, Vec<String>> {
     use TreeMapResult::*;
 
     match handle.clone().data {
@@ -467,7 +463,7 @@ fn extract_style_nodes<'a, T: Write>(
                     // Assume just a flat text node
                     for child in handle.children.borrow().iter() {
                         if let NodeData::Text { ref contents } = child.data {
-                            result += &String::from(contents.borrow().deref());
+                            result += &contents.borrow();
                         }
                     }
                     Finished(vec![result])

src/css/parser.rs

@@ -371,12 +371,12 @@ fn parse_token_not_semicolon(text: &str) -> IResult<&str, Token> {
 fn parse_value(text: &str) -> IResult<&str, RawValue> {
     let (rest, mut tokens) = many0(parse_token_not_semicolon)(text)?;
     let mut important = false;
-    if tokens.len() >= 2
-        && tokens[tokens.len() - 2..] == [Token::Delim('!'), Token::Ident("important".into())]
-    {
-        tokens.pop();
-        tokens.pop();
-        important = true;
+    if let [.., Token::Delim('!'), Token::Ident(x)] = &tokens[..] {
+        if x == "important" {
+            tokens.pop();
+            tokens.pop();
+            important = true;
+        }
     }
     Ok((rest, RawValue { tokens, important }))
 }
@@ -492,21 +492,18 @@ fn parse_color(tokens: &[Token]) -> Result<Colour, nom::Err<nom::error::Error<&'
             };
             Ok(colour)
         }
-        [Token::Function(name), .., Token::CloseRound] => {
+        [Token::Function(name), rgb_args @ .., Token::CloseRound] => {
             use Token::*;
             match name.deref() {
-                "rgb" => {
-                    let rgb_args = &tokens[1..tokens.len() - 1];
-                    match rgb_args {
-                        [Number(r), Comma, Number(g), Comma, Number(b)] => {
-                            let r = r.parse().map_err(|_e| empty_fail())?;
-                            let g = g.parse().map_err(|_e| empty_fail())?;
-                            let b = b.parse().map_err(|_e| empty_fail())?;
-                            Ok(Colour::Rgb(r, g, b))
-                        }
-                        _ => Err(empty_fail()),
+                "rgb" => match rgb_args {
+                    [Number(r), Comma, Number(g), Comma, Number(b)] => {
+                        let r = r.parse().map_err(|_e| empty_fail())?;
+                        let g = g.parse().map_err(|_e| empty_fail())?;
+                        let b = b.parse().map_err(|_e| empty_fail())?;
+                        Ok(Colour::Rgb(r, g, b))
                     }
-                }
+                    _ => Err(empty_fail()),
+                },
                 _ => Err(empty_fail()),
             }
         }