Format remaining files

1 files changed, 75 insertions, 70 deletions

diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index 3e82a49b348..433f58992af 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -270,7 +270,9 @@ where
 
     // Ensure they're actually all compound selectors without pseudo-elements.
     if selector.has_pseudo_element() {
-        return Err(location.new_custom_error(SelectorParseErrorKind::PseudoElementInComplexSelector));
+        return Err(
+            location.new_custom_error(SelectorParseErrorKind::PseudoElementInComplexSelector)
+        );
     }
 
     if selector.iter_raw_match_order().any(|s| s.is_combinator()) {
@@ -457,7 +459,7 @@ where
                 ) {
                     return false;
                 }
-            },
+            }
             AttributeOther(ref attr_selector) if !attr_selector.never_matches => {
                 let empty_string;
                 let namespace = match attr_selector.namespace() {
@@ -1720,7 +1722,8 @@ where
             if namespace.is_none() && include!(concat!(
                 env!("OUT_DIR"),
                 "/ascii_case_insensitive_html_attributes.rs"
-            )).contains(&*local_name_lower_cow)
+            ))
+            .contains(&*local_name_lower_cow)
             {
                 case_sensitivity =
                     ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
@@ -1872,33 +1875,30 @@ where
             SimpleSelectorParseResult::PseudoElement(p) => {
                 slotted_selector = None;
                 pseudo_element = Some(p);
-            }
+            },
             SimpleSelectorParseResult::SlottedPseudo(selector) => {
                 slotted_selector = Some(selector);
-                let maybe_pseudo = parse_one_simple_selector(
-                    parser,
-                    input,
-                    /* inside_negation = */ false,
-                )?;
+                let maybe_pseudo =
+                    parse_one_simple_selector(parser, input, /* inside_negation = */ false)?;
 
                 pseudo_element = match maybe_pseudo {
                     None => None,
                     Some(SimpleSelectorParseResult::PseudoElement(pseudo)) => {
                         if !pseudo.valid_after_slotted() {
                             return Err(input.new_custom_error(
-                                SelectorParseErrorKind::InvalidPseudoElementAfterSlotted
+                                SelectorParseErrorKind::InvalidPseudoElementAfterSlotted,
                             ));
                         }
                         Some(pseudo)
-                    }
+                    },
                     Some(SimpleSelectorParseResult::SimpleSelector(..)) |
                     Some(SimpleSelectorParseResult::SlottedPseudo(..)) => {
                         return Err(input.new_custom_error(
-                            SelectorParseErrorKind::NonPseudoElementAfterSlotted
+                            SelectorParseErrorKind::NonPseudoElementAfterSlotted,
                         ));
-                    }
+                    },
                 };
-            }
+            },
         }
 
         debug_assert!(slotted_selector.is_some() || pseudo_element.is_some());
@@ -1925,14 +1925,12 @@ where
                 let name = match input.next_including_whitespace()? {
                     &Token::Ident(ref name) => name.clone(),
                     t => {
-                        return Err(location.new_custom_error(
-                            SelectorParseErrorKind::NoIdentForPseudo(t.clone()),
-                        ))
+                        return Err(location
+                            .new_custom_error(SelectorParseErrorKind::NoIdentForPseudo(t.clone())))
                     },
                 };
 
-                let pseudo_class =
-                    P::parse_non_ts_pseudo_class(parser, location, name.clone())?;
+                let pseudo_class = P::parse_non_ts_pseudo_class(parser, location, name.clone())?;
                 if !p.supports_pseudo_class(&pseudo_class) {
                     return Err(input.new_custom_error(
                         SelectorParseErrorKind::UnsupportedPseudoClassOrElement(name),
@@ -2139,7 +2137,8 @@ where
         "last-of-type" => Ok(Component::LastOfType),
         "only-of-type" => Ok(Component::OnlyOfType),
         _ => Err(())
-    }).or_else(|()| {
+    })
+    .or_else(|()| {
         P::parse_non_ts_pseudo_class(parser, location, name).map(Component::NonTSPseudoClass)
     })
 }
@@ -2422,9 +2421,9 @@ pub mod tests {
                 vec![Component::LocalName(LocalName {
                     name: DummyAtom::from("EeÉ"),
                     lower_name: DummyAtom::from("eeÉ"),
-                }), ],
+                })],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("|e"),
@@ -2437,7 +2436,7 @@ pub mod tests {
                     }),
                 ],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         // When the default namespace is not set, *| should be elided.
         // https://github.com/servo/servo/pull/17537
@@ -2447,9 +2446,9 @@ pub mod tests {
                 vec![Component::LocalName(LocalName {
                     name: DummyAtom::from("e"),
                     lower_name: DummyAtom::from("e"),
-                }), ],
+                })],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         // When the default namespace is set, *| should _not_ be elided (as foo
         // is no longer equivalent to *|foo--the former is only for foo in the
@@ -2469,14 +2468,14 @@ pub mod tests {
                     }),
                 ],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("*"),
             Ok(SelectorList::from_vec(vec![Selector::from_vec(
                 vec![Component::ExplicitUniversalType],
                 specificity(0, 0, 0)
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("|*"),
@@ -2486,14 +2485,14 @@ pub mod tests {
                     Component::ExplicitUniversalType,
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_expected("*|*", Some("*")),
             Ok(SelectorList::from_vec(vec![Selector::from_vec(
                 vec![Component::ExplicitUniversalType],
                 specificity(0, 0, 0)
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(
@@ -2506,7 +2505,7 @@ pub mod tests {
                     Component::ExplicitUniversalType,
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse(".foo:lang(en-US)"),
@@ -2516,14 +2515,14 @@ pub mod tests {
                     Component::NonTSPseudoClass(PseudoClass::Lang("en-US".to_owned())),
                 ],
                 specificity(0, 2, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("#bar"),
             Ok(SelectorList::from_vec(vec![Selector::from_vec(
                 vec![Component::ID(DummyAtom::from("bar"))],
                 specificity(1, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("e.foo#bar"),
@@ -2537,7 +2536,7 @@ pub mod tests {
                     Component::ID(DummyAtom::from("bar")),
                 ],
                 specificity(1, 1, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("e.foo #bar"),
@@ -2552,7 +2551,7 @@ pub mod tests {
                     Component::ID(DummyAtom::from("bar")),
                 ],
                 specificity(1, 1, 1),
-            ), ]))
+            )]))
         );
         // Default namespace does not apply to attribute selectors
         // https://github.com/mozilla/servo/pull/1652
@@ -2563,9 +2562,9 @@ pub mod tests {
                 vec![Component::AttributeInNoNamespaceExists {
                     local_name: DummyAtom::from("Foo"),
                     local_name_lower: DummyAtom::from("foo"),
-                }, ],
+                }],
                 specificity(0, 1, 0),
-            ), ]))
+            )]))
         );
         assert!(parse_ns("svg|circle", &parser).is_err());
         parser
@@ -2582,7 +2581,7 @@ pub mod tests {
                     }),
                 ],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns("svg|*", &parser),
@@ -2592,7 +2591,7 @@ pub mod tests {
                     Component::ExplicitUniversalType,
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         // Default namespace does not apply to attribute selectors
         // https://github.com/mozilla/servo/pull/1652
@@ -2610,7 +2609,7 @@ pub mod tests {
                     },
                 ],
                 specificity(0, 1, 0),
-            ), ]))
+            )]))
         );
         // Default namespace does apply to type selectors
         assert_eq!(
@@ -2624,7 +2623,7 @@ pub mod tests {
                     }),
                 ],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns("*", &parser),
@@ -2634,7 +2633,7 @@ pub mod tests {
                     Component::ExplicitUniversalType,
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns("*|*", &parser),
@@ -2644,7 +2643,7 @@ pub mod tests {
                     Component::ExplicitUniversalType,
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         // Default namespace applies to universal and type selectors inside :not and :matches,
         // but not otherwise.
@@ -2660,7 +2659,7 @@ pub mod tests {
                     ),
                 ],
                 specificity(0, 1, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(":not(*)", &parser),
@@ -2671,12 +2670,13 @@ pub mod tests {
                         vec![
                             Component::DefaultNamespace(MATHML.into()),
                             Component::ExplicitUniversalType,
-                        ].into_boxed_slice()
+                        ]
+                        .into_boxed_slice()
                         .into(),
                     ),
                 ],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(":not(e)", &parser),
@@ -2690,12 +2690,13 @@ pub mod tests {
                                 name: DummyAtom::from("e"),
                                 lower_name: DummyAtom::from("e"),
                             }),
-                        ].into_boxed_slice()
+                        ]
+                        .into_boxed_slice()
                         .into(),
                     ),
                 ],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("[attr|=\"foo\"]"),
@@ -2706,9 +2707,9 @@ pub mod tests {
                     value: DummyAtom::from("foo"),
                     never_matches: false,
                     case_sensitivity: ParsedCaseSensitivity::CaseSensitive,
-                }, ],
+                }],
                 specificity(0, 1, 0),
-            ), ]))
+            )]))
         );
         // https://github.com/mozilla/servo/issues/1723
         assert_eq!(
@@ -2716,7 +2717,7 @@ pub mod tests {
             Ok(SelectorList::from_vec(vec![Selector::from_vec(
                 vec![Component::PseudoElement(PseudoElement::Before)],
                 specificity(0, 0, 1) | HAS_PSEUDO_BIT,
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("::before:hover"),
@@ -2726,7 +2727,7 @@ pub mod tests {
                     Component::NonTSPseudoClass(PseudoClass::Hover),
                 ],
                 specificity(0, 1, 1) | HAS_PSEUDO_BIT,
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("::before:hover:hover"),
@@ -2737,7 +2738,7 @@ pub mod tests {
                     Component::NonTSPseudoClass(PseudoClass::Hover),
                 ],
                 specificity(0, 2, 1) | HAS_PSEUDO_BIT,
-            ), ]))
+            )]))
         );
         assert!(parse("::before:hover:active").is_err());
         assert!(parse("::before:hover .foo").is_err());
@@ -2760,7 +2761,7 @@ pub mod tests {
                     Component::PseudoElement(PseudoElement::After),
                 ],
                 specificity(0, 0, 2) | HAS_PSEUDO_BIT,
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse("#d1 > .ok"),
@@ -2771,7 +2772,7 @@ pub mod tests {
                     Component::Class(DummyAtom::from("ok")),
                 ],
                 (1 << 20) + (1 << 10) + (0 << 0),
-            ), ]))
+            )]))
         );
         parser.default_ns = None;
         assert!(parse(":not(#provel.old)").is_err());
@@ -2784,9 +2785,9 @@ pub mod tests {
                     vec![Component::ID(DummyAtom::from("provel"))]
                         .into_boxed_slice()
                         .into(),
-                ), ],
+                )],
                 specificity(1, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(":not(svg|circle)", &parser),
@@ -2798,11 +2799,12 @@ pub mod tests {
                             name: DummyAtom::from("circle"),
                             lower_name: DummyAtom::from("circle"),
                         }),
-                    ].into_boxed_slice()
+                    ]
+                    .into_boxed_slice()
                     .into(),
-                ), ],
+                )],
                 specificity(0, 0, 1),
-            ), ]))
+            )]))
         );
         // https://github.com/servo/servo/issues/16017
         assert_eq!(
@@ -2812,9 +2814,9 @@ pub mod tests {
                     vec![Component::ExplicitUniversalType]
                         .into_boxed_slice()
                         .into(),
-                ), ],
+                )],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(":not(|*)", &parser),
@@ -2823,11 +2825,12 @@ pub mod tests {
                     vec![
                         Component::ExplicitNoNamespace,
                         Component::ExplicitUniversalType,
-                    ].into_boxed_slice()
+                    ]
+                    .into_boxed_slice()
                     .into(),
-                ), ],
+                )],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         // *| should be elided if there is no default namespace.
         // https://github.com/servo/servo/pull/17537
@@ -2838,9 +2841,9 @@ pub mod tests {
                     vec![Component::ExplicitUniversalType]
                         .into_boxed_slice()
                         .into(),
-                ), ],
+                )],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
         assert_eq!(
             parse_ns(":not(svg|*)", &parser),
@@ -2849,11 +2852,12 @@ pub mod tests {
                     vec![
                         Component::Namespace(DummyAtom("svg".into()), SVG.into()),
                         Component::ExplicitUniversalType,
-                    ].into_boxed_slice()
+                    ]
+                    .into_boxed_slice()
                     .into(),
-                ), ],
+                )],
                 specificity(0, 0, 0),
-            ), ]))
+            )]))
         );
 
         assert!(parse("::slotted()").is_err());
@@ -2891,7 +2895,8 @@ pub mod tests {
         let selector = &parse_ns(
             "*|*::before",
             &DummyParser::default_with_namespace(DummyAtom::from("https://mozilla.org")),
-        ).unwrap()
+        )
+        .unwrap()
         .0[0];
         assert!(selector.is_universal());
     }