Fix up unit tests.

MozReview-Commit-ID: 9eyOhoQ02qX

4 files changed, 246 insertions, 300 deletions

diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index 423d092978a..a7f3d259fbd 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -162,6 +162,11 @@ impl<Impl: SelectorImpl> SelectorList<Impl> {
         input.parse_comma_separated(|input| parse_selector(parser, input).map(SelectorAndHashes::new))
              .map(SelectorList)
     }
+
+    /// Creates a SelectorList from a Vec of selectors. Used in tests.
+    pub fn from_vec(v: Vec<Selector<Impl>>) -> Self {
+        SelectorList(v.into_iter().map(SelectorAndHashes::new).collect())
+    }
 }
 
 /// Copied from Gecko, who copied it from WebKit. Note that increasing the
@@ -1709,7 +1714,7 @@ pub mod tests {
         let result = SelectorList::parse(parser, &mut CssParser::new(input));
         if let Ok(ref selectors) = result {
             assert_eq!(selectors.0.len(), 1);
-            assert_eq!(selectors.0[0].to_css_string(), input);
+            assert_eq!(selectors.0[0].selector.to_css_string(), input);
         }
         result
     }
@@ -1732,185 +1737,164 @@ pub mod tests {
         assert_eq!(parse(""), Err(())) ;
         assert_eq!(parse(":lang(4)"), Err(())) ;
         assert_eq!(parse(":lang(en US)"), Err(())) ;
-        assert_eq!(parse("EeÉ"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+        assert_eq!(parse("EeÉ"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::LocalName(LocalName {
                     name: DummyAtom::from("EeÉ"),
-                    lower_name: DummyAtom::from("eeÉ") })),
-            ),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
-        assert_eq!(parse("|e"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+                    lower_name: DummyAtom::from("eeÉ") })
+            ), specificity(0, 0, 1))
+        ))));
+        assert_eq!(parse("|e"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::ExplicitNoNamespace,
                 Component::LocalName(LocalName {
                     name: DummyAtom::from("e"),
                     lower_name: DummyAtom::from("e")
-                }),
-            )),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
+                })), specificity(0, 0, 1))
+        ))));
         // https://github.com/servo/servo/issues/16020
-        assert_eq!(parse("*|e"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+        assert_eq!(parse("*|e"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::ExplicitAnyNamespace,
                 Component::LocalName(LocalName {
                     name: DummyAtom::from("e"),
                     lower_name: DummyAtom::from("e")
-                }),
-            )),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
-        assert_eq!(parse("*"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+                })
+            ), specificity(0, 0, 1))
+        ))));
+        assert_eq!(parse("*"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::ExplicitUniversalType,
-            )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse("|*"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+            ), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse("|*"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::ExplicitNoNamespace,
                 Component::ExplicitUniversalType,
-            )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse("*|*"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+            ), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse("*|*"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::ExplicitAnyNamespace,
                 Component::ExplicitUniversalType,
-            )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse(".foo:lang(en-US)"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec![
+            ), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse(".foo:lang(en-US)"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                     Component::Class(DummyAtom::from("foo")),
                     Component::NonTSPseudoClass(PseudoClass::Lang("en-US".to_owned()))
-            ]),
-            specificity_and_flags: specificity(0, 2, 0),
-        }))));
-        assert_eq!(parse("#bar"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::ID(DummyAtom::from("bar")))),
-            specificity_and_flags: specificity(1, 0, 0),
-        }))));
-        assert_eq!(parse("e.foo#bar"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::LocalName(LocalName {
-                                            name: DummyAtom::from("e"),
-                                            lower_name: DummyAtom::from("e") }),
-                                       Component::Class(DummyAtom::from("foo")),
-                                       Component::ID(DummyAtom::from("bar")))),
-            specificity_and_flags: specificity(1, 1, 1),
-        }))));
-        assert_eq!(parse("e.foo #bar"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
-                           Component::LocalName(LocalName {
-                               name: DummyAtom::from("e"),
-                               lower_name: DummyAtom::from("e")
-                           }),
-                           Component::Class(DummyAtom::from("foo")),
-                           Component::Combinator(Combinator::Descendant),
-                           Component::ID(DummyAtom::from("bar")),
-                       )),
-            specificity_and_flags: specificity(1, 1, 1),
-        }))));
+            ), 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"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::LocalName(LocalName {
+                    name: DummyAtom::from("e"),
+                    lower_name: DummyAtom::from("e")
+                }),
+                Component::Class(DummyAtom::from("foo")),
+                Component::ID(DummyAtom::from("bar"))
+            ), specificity(1, 1, 1))
+        ))));
+        assert_eq!(parse("e.foo #bar"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+               Component::LocalName(LocalName {
+                   name: DummyAtom::from("e"),
+                   lower_name: DummyAtom::from("e")
+               }),
+               Component::Class(DummyAtom::from("foo")),
+               Component::Combinator(Combinator::Descendant),
+               Component::ID(DummyAtom::from("bar")),
+            ), specificity(1, 1, 1))
+        ))));
         // Default namespace does not apply to attribute selectors
         // https://github.com/mozilla/servo/pull/1652
         let mut parser = DummyParser::default();
-        assert_eq!(parse_ns("[Foo]", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec![
+        assert_eq!(parse_ns("[Foo]", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::AttributeInNoNamespaceExists {
                     local_name: DummyAtom::from("Foo"),
                     local_name_lower: DummyAtom::from("foo"),
                 }
-            ]),
-            specificity_and_flags: specificity(0, 1, 0),
-        }))));
+            ), specificity(0, 1, 0))
+        ))));
         assert_eq!(parse_ns("svg|circle", &parser), Err(()));
         parser.ns_prefixes.insert(DummyAtom("svg".into()), DummyAtom(SVG.into()));
-        assert_eq!(parse_ns("svg|circle", &parser), Ok(SelectorList(vec![Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::Namespace(DummyAtom("svg".into()), SVG.into()),
-                    Component::LocalName(LocalName {
-                        name: DummyAtom::from("circle"),
-                        lower_name: DummyAtom::from("circle"),
-                    })
-                ]),
-            specificity_and_flags: specificity(0, 0, 1),
-        }])));
-        assert_eq!(parse_ns("svg|*", &parser), Ok(SelectorList(vec![Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::Namespace(DummyAtom("svg".into()), SVG.into()),
-                    Component::ExplicitUniversalType,
-                ]),
-            specificity_and_flags: specificity(0, 0, 0),
-        }])));
+        assert_eq!(parse_ns("svg|circle", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::Namespace(DummyAtom("svg".into()), SVG.into()),
+                Component::LocalName(LocalName {
+                    name: DummyAtom::from("circle"),
+                    lower_name: DummyAtom::from("circle"),
+                })
+            ), specificity(0, 0, 1))
+        ))));
+        assert_eq!(parse_ns("svg|*", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::Namespace(DummyAtom("svg".into()), SVG.into()),
+                Component::ExplicitUniversalType,
+            ), specificity(0, 0, 0))
+        ))));
         // Default namespace does not apply to attribute selectors
         // https://github.com/mozilla/servo/pull/1652
         // but it does apply to implicit type selectors
         // https://github.com/servo/rust-selectors/pull/82
         parser.default_ns = Some(MATHML.into());
-        assert_eq!(parse_ns("[Foo]", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::DefaultNamespace(MATHML.into()),
-                    Component::AttributeInNoNamespaceExists {
-                        local_name: DummyAtom::from("Foo"),
-                        local_name_lower: DummyAtom::from("foo"),
-                    },
-                ]),
-            specificity_and_flags: specificity(0, 1, 0),
-        }))));
+        assert_eq!(parse_ns("[Foo]", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::DefaultNamespace(MATHML.into()),
+                Component::AttributeInNoNamespaceExists {
+                    local_name: DummyAtom::from("Foo"),
+                    local_name_lower: DummyAtom::from("foo"),
+                },
+            ), specificity(0, 1, 0))
+        ))));
         // Default namespace does apply to type selectors
-        assert_eq!(parse_ns("e", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec!(
-                    Component::DefaultNamespace(MATHML.into()),
-                    Component::LocalName(LocalName {
-                        name: DummyAtom::from("e"),
-                        lower_name: DummyAtom::from("e") }),
-                )),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
-        assert_eq!(parse_ns("*", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec!(
-                    Component::DefaultNamespace(MATHML.into()),
-                    Component::ExplicitUniversalType,
-                )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse_ns("*|*", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec!(
-                    Component::ExplicitAnyNamespace,
-                    Component::ExplicitUniversalType,
-                )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
+        assert_eq!(parse_ns("e", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::DefaultNamespace(MATHML.into()),
+                Component::LocalName(LocalName {
+                    name: DummyAtom::from("e"),
+                    lower_name: DummyAtom::from("e") }),
+            ), specificity(0, 0, 1))
+        ))));
+        assert_eq!(parse_ns("*", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::DefaultNamespace(MATHML.into()),
+                Component::ExplicitUniversalType,
+            ), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse_ns("*|*", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::ExplicitAnyNamespace,
+                Component::ExplicitUniversalType,
+            ), specificity(0, 0, 0))
+        ))));
         // Default namespace applies to universal and type selectors inside :not and :matches,
         // but not otherwise.
-        assert_eq!(parse_ns(":not(.cl)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+        assert_eq!(parse_ns(":not(.cl)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::DefaultNamespace(MATHML.into()),
                 Component::Negation(vec![
                     Component::Class(DummyAtom::from("cl"))
                 ].into_boxed_slice()),
-            )),
-            specificity_and_flags: specificity(0, 1, 0),
-        }))));
-        assert_eq!(parse_ns(":not(*)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+            ), specificity(0, 1, 0))
+        ))));
+        assert_eq!(parse_ns(":not(*)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::DefaultNamespace(MATHML.into()),
                 Component::Negation(vec![
                     Component::DefaultNamespace(MATHML.into()),
                     Component::ExplicitUniversalType,
                 ].into_boxed_slice()),
-            )),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse_ns(":not(e)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(
+            ), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse_ns(":not(e)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
                 Component::DefaultNamespace(MATHML.into()),
                 Component::Negation(vec![
                     Component::DefaultNamespace(MATHML.into()),
@@ -1919,51 +1903,39 @@ pub mod tests {
                         lower_name: DummyAtom::from("e")
                     }),
                 ].into_boxed_slice())
-            )),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
-        assert_eq!(parse("[attr |= \"foo\"]"), Ok(SelectorList(vec![Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::AttributeInNoNamespace {
-                        local_name: DummyAtom::from("attr"),
-                        local_name_lower: DummyAtom::from("attr"),
-                        operator: AttrSelectorOperator::DashMatch,
-                        value: DummyAtom::from("foo"),
-                        never_matches: false,
-                        case_sensitivity: ParsedCaseSensitivity::CaseSensitive,
-                    }
-                ]),
-            specificity_and_flags: specificity(0, 1, 0),
-        }])));
+            ), specificity(0, 0, 1))
+        ))));
+        assert_eq!(parse("[attr |= \"foo\"]"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::AttributeInNoNamespace {
+                    local_name: DummyAtom::from("attr"),
+                    local_name_lower: DummyAtom::from("attr"),
+                    operator: AttrSelectorOperator::DashMatch,
+                    value: DummyAtom::from("foo"),
+                    never_matches: false,
+                    case_sensitivity: ParsedCaseSensitivity::CaseSensitive,
+                }
+            ), specificity(0, 1, 0))
+        ))));
         // https://github.com/mozilla/servo/issues/1723
-        assert_eq!(parse("::before"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::PseudoElement(PseudoElement::Before),
-                ]
-            ),
-            specificity_and_flags: specificity(0, 0, 1) | HAS_PSEUDO_BIT,
-        }))));
-        assert_eq!(parse("::before:hover"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::PseudoElement(PseudoElement::Before),
-                    Component::NonTSPseudoClass(PseudoClass::Hover),
-                ]
-            ),
-            specificity_and_flags: specificity(0, 1, 1) | HAS_PSEUDO_BIT,
-        }))));
-        assert_eq!(parse("::before:hover:hover"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::PseudoElement(PseudoElement::Before),
-                    Component::NonTSPseudoClass(PseudoClass::Hover),
-                    Component::NonTSPseudoClass(PseudoClass::Hover),
-                ]
-            ),
-            specificity_and_flags: specificity(0, 2, 1) | HAS_PSEUDO_BIT,
-        }))));
+        assert_eq!(parse("::before"), 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"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::PseudoElement(PseudoElement::Before),
+                Component::NonTSPseudoClass(PseudoClass::Hover),
+            ), specificity(0, 1, 1) | HAS_PSEUDO_BIT)
+        ))));
+        assert_eq!(parse("::before:hover:hover"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::PseudoElement(PseudoElement::Before),
+                Component::NonTSPseudoClass(PseudoClass::Hover),
+                Component::NonTSPseudoClass(PseudoClass::Hover),
+            ), specificity(0, 2, 1) | HAS_PSEUDO_BIT)
+        ))));
         assert_eq!(parse("::before:hover:active"), Err(()));
         assert_eq!(parse("::before:hover .foo"), Err(()));
         assert_eq!(parse("::before .foo"), Err(()));
@@ -1972,41 +1944,35 @@ pub mod tests {
 
         // https://github.com/servo/servo/issues/15335
         assert_eq!(parse(":: before"), Err(()));
-        assert_eq!(parse("div ::after"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                     Component::LocalName(LocalName {
-                        name: DummyAtom::from("div"),
-                        lower_name: DummyAtom::from("div") }),
-                    Component::Combinator(Combinator::Descendant),
-                    Component::Combinator(Combinator::PseudoElement),
-                    Component::PseudoElement(PseudoElement::After),
-                ]),
-            specificity_and_flags: specificity(0, 0, 2) | HAS_PSEUDO_BIT,
-        }))));
-        assert_eq!(parse("#d1 > .ok"), Ok(SelectorList(vec![Selector {
-            inner: SelectorInner::from_vec(
-                vec![
-                    Component::ID(DummyAtom::from("d1")),
-                    Component::Combinator(Combinator::Child),
-                    Component::Class(DummyAtom::from("ok")),
-                ]),
-            specificity_and_flags: (1 << 20) + (1 << 10) + (0 << 0),
-        }])));
+        assert_eq!(parse("div ::after"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                 Component::LocalName(LocalName {
+                    name: DummyAtom::from("div"),
+                    lower_name: DummyAtom::from("div") }),
+                Component::Combinator(Combinator::Descendant),
+                Component::Combinator(Combinator::PseudoElement),
+                Component::PseudoElement(PseudoElement::After),
+            ), specificity(0, 0, 2) | HAS_PSEUDO_BIT)
+        ))));
+        assert_eq!(parse("#d1 > .ok"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(
+                Component::ID(DummyAtom::from("d1")),
+                Component::Combinator(Combinator::Child),
+                Component::Class(DummyAtom::from("ok")),
+            ), (1 << 20) + (1 << 10) + (0 << 0))
+        ))));
         parser.default_ns = None;
         assert_eq!(parse(":not(#provel.old)"), Err(()));
         assert_eq!(parse(":not(#provel > old)"), Err(()));
         assert!(parse("table[rules]:not([rules = \"none\"]):not([rules = \"\"])").is_ok());
-        assert_eq!(parse(":not(#provel)"), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
-                vec![
+        assert_eq!(parse(":not(#provel)"), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(vec!(
                     Component::ID(DummyAtom::from("provel")),
-                ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(1, 0, 0),
-        }))));
-        assert_eq!(parse_ns(":not(svg|circle)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
+                ).into_boxed_slice()
+            )), specificity(1, 0, 0))
+        ))));
+        assert_eq!(parse_ns(":not(svg|circle)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(
                 vec![
                     Component::Namespace(DummyAtom("svg".into()), SVG.into()),
                     Component::LocalName(LocalName {
@@ -2014,52 +1980,47 @@ pub mod tests {
                         lower_name: DummyAtom::from("circle")
                     }),
                 ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(0, 0, 1),
-        }))));
+            )), specificity(0, 0, 1))
+        ))));
         // https://github.com/servo/servo/issues/16017
-        assert_eq!(parse_ns(":not(*)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
+        assert_eq!(parse_ns(":not(*)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(
                 vec![
                     Component::ExplicitUniversalType,
                 ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse_ns(":not(|*)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
+            )), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse_ns(":not(|*)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(
                 vec![
                     Component::ExplicitNoNamespace,
                     Component::ExplicitUniversalType,
                 ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse_ns(":not(*|*)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
+            )), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse_ns(":not(*|*)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(
                 vec![
                     Component::ExplicitAnyNamespace,
                     Component::ExplicitUniversalType,
                 ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
-        assert_eq!(parse_ns(":not(svg|*)", &parser), Ok(SelectorList(vec!(Selector {
-            inner: SelectorInner::from_vec(vec!(Component::Negation(
+            )), specificity(0, 0, 0))
+        ))));
+        assert_eq!(parse_ns(":not(svg|*)", &parser), Ok(SelectorList::from_vec(vec!(
+            Selector::from_vec(vec!(Component::Negation(
                 vec![
                     Component::Namespace(DummyAtom("svg".into()), SVG.into()),
                     Component::ExplicitUniversalType,
                 ].into_boxed_slice()
-            ))),
-            specificity_and_flags: specificity(0, 0, 0),
-        }))));
+            )), specificity(0, 0, 0))
+        ))));
     }
 
     #[test]
     fn test_pseudo_iter() {
-        let selector = &parse("q::before").unwrap().0[0];
+        let selector = &parse("q::before").unwrap().0[0].selector;
         assert!(!selector.is_universal());
-        let mut iter = selector.inner.complex.iter();
+        let mut iter = selector.iter();
         assert_eq!(iter.next(), Some(&Component::PseudoElement(PseudoElement::Before)));
         assert_eq!(iter.next(), None);
         let combinator = iter.next_sequence();
@@ -2071,15 +2032,15 @@ pub mod tests {
 
     #[test]
     fn test_universal() {
-        let selector = &parse("*|*::before").unwrap().0[0];
+        let selector = &parse("*|*::before").unwrap().0[0].selector;
         assert!(selector.is_universal());
     }
 
     #[test]
     fn test_empty_pseudo_iter() {
-        let selector = &parse("::before").unwrap().0[0];
+        let selector = &parse("::before").unwrap().0[0].selector;
         assert!(selector.is_universal());
-        let mut iter = selector.inner.complex.iter();
+        let mut iter = selector.iter();
         assert_eq!(iter.next(), Some(&Component::PseudoElement(PseudoElement::Before)));
         assert_eq!(iter.next(), None);
         assert_eq!(iter.next_sequence(), None);
@@ -2103,11 +2064,11 @@ pub mod tests {
     #[test]
     fn visitor() {
         let mut test_visitor = TestVisitor { seen: vec![], };
-        parse(":not(:hover) ~ label").unwrap().0[0].visit(&mut test_visitor);
+        parse(":not(:hover) ~ label").unwrap().0[0].selector.visit(&mut test_visitor);
         assert!(test_visitor.seen.contains(&":hover".into()));
 
         let mut test_visitor = TestVisitor { seen: vec![], };
-        parse("::before:hover").unwrap().0[0].visit(&mut test_visitor);
+        parse("::before:hover").unwrap().0[0].selector.visit(&mut test_visitor);
         assert!(test_visitor.seen.contains(&":hover".into()));
     }
 }
diff --git a/components/selectors/size_of_tests.rs b/components/selectors/size_of_tests.rs
index 5fec3085fcb..d9ed1651cf7 100644
--- a/components/selectors/size_of_tests.rs
+++ b/components/selectors/size_of_tests.rs
@@ -11,10 +11,8 @@ use precomputed_hash::PrecomputedHash;
 use std::fmt;
 use visitor::SelectorVisitor;
 
-size_of_test!(size_of_selector, Selector<Impl>, 48);
+size_of_test!(size_of_selector, Selector<Impl>, 8);
 size_of_test!(size_of_pseudo_element, gecko_like_types::PseudoElement, 1);
-size_of_test!(size_of_selector_inner, SelectorInner<Impl>, 40);
-size_of_test!(size_of_complex_selector, ComplexSelector<Impl>, 24);
 
 size_of_test!(size_of_component, Component<Impl>, 32);
 size_of_test!(size_of_pseudo_class, PseudoClass, 24);
diff --git a/tests/unit/style/stylesheets.rs b/tests/unit/style/stylesheets.rs
index ce465b0f1ac..686a3979a9a 100644
--- a/tests/unit/style/stylesheets.rs
+++ b/tests/unit/style/stylesheets.rs
@@ -90,26 +90,23 @@ fn test_parse_stylesheet() {
                 },
             }))),
             CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
-                selectors: SelectorList(vec![
-                    Selector::new_for_unit_testing(
-                        SelectorInner::from_vec(vec![
-                            Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
-                            Component::LocalName(LocalName {
-                                name: local_name!("input"),
-                                lower_name: local_name!("input"),
-                            }),
-                            Component::AttributeInNoNamespace {
-                                local_name: local_name!("type"),
-                                local_name_lower: local_name!("type"),
-                                operator: AttrSelectorOperator::Equal,
-                                value: "hidden".to_owned(),
-                                case_sensitivity: ParsedCaseSensitivity::AsciiCaseInsensitive,
-                                never_matches: false,
-                            }
-                        ]),
-                        (0 << 20) + (1 << 10) + (1 << 0)
-                    ),
-                ]),
+                selectors: SelectorList::from_vec(vec!(
+                    Selector::from_vec(vec!(
+                        Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
+                        Component::LocalName(LocalName {
+                            name: local_name!("input"),
+                            lower_name: local_name!("input"),
+                        }),
+                        Component::AttributeInNoNamespace {
+                            local_name: local_name!("type"),
+                            local_name_lower: local_name!("type"),
+                            operator: AttrSelectorOperator::Equal,
+                            value: "hidden".to_owned(),
+                            case_sensitivity: ParsedCaseSensitivity::AsciiCaseInsensitive,
+                            never_matches: false,
+                        }
+                    ), (0 << 20) + (1 << 10) + (1 << 0))
+                )),
                 block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
                     (PropertyDeclaration::Display(longhands::display::SpecifiedValue::none),
                      Importance::Important),
@@ -123,28 +120,23 @@ fn test_parse_stylesheet() {
                 },
             }))),
             CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
-                selectors: SelectorList(vec![
-                    Selector::new_for_unit_testing(
-                        SelectorInner::from_vec(vec![
+                selectors: SelectorList::from_vec(vec!(
+                    Selector::from_vec(vec!(
                             Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
                             Component::LocalName(LocalName {
                                 name: local_name!("html"),
                                 lower_name: local_name!("html"),
                             }),
-                        ]),
-                        (0 << 20) + (0 << 10) + (1 << 0)
-                    ),
-                    Selector::new_for_unit_testing(
-                        SelectorInner::from_vec(vec![
-                            Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
-                            Component::LocalName(LocalName {
-                                name: local_name!("body"),
-                                lower_name: local_name!("body"),
-                            }),
-                        ]),
-                        (0 << 20) + (0 << 10) + (1 << 0)
+                        ), (0 << 20) + (0 << 10) + (1 << 0)),
+                    Selector::from_vec(vec!(
+                        Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
+                        Component::LocalName(LocalName {
+                            name: local_name!("body"),
+                            lower_name: local_name!("body"),
+                        })
+                        ), (0 << 20) + (0 << 10) + (1 << 0)
                     ),
-                ]),
+                )),
                 block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
                     (PropertyDeclaration::Display(longhands::display::SpecifiedValue::block),
                      Importance::Normal),
@@ -155,18 +147,15 @@ fn test_parse_stylesheet() {
                 },
             }))),
             CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
-                selectors: SelectorList(vec![
-                    Selector::new_for_unit_testing(
-                        SelectorInner::from_vec(vec![
-                            Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
-                            Component::ID(Atom::from("d1")),
-                            Component::Combinator(Combinator::Child),
-                            Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
-                            Component::Class(Atom::from("ok")),
-                        ]),
-                        (1 << 20) + (1 << 10) + (0 << 0)
-                    ),
-                ]),
+                selectors: SelectorList::from_vec(vec!(
+                    Selector::from_vec(vec!(
+                        Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
+                        Component::ID(Atom::from("d1")),
+                        Component::Combinator(Combinator::Child),
+                        Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
+                        Component::Class(Atom::from("ok"))
+                    ), (1 << 20) + (1 << 10) + (0 << 0))
+                )),
                 block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
                     (PropertyDeclaration::BackgroundColor(
                         longhands::background_color::SpecifiedValue {
diff --git a/tests/unit/style/stylist.rs b/tests/unit/style/stylist.rs
index afd967338f9..17faaddd04a 100644
--- a/tests/unit/style/stylist.rs
+++ b/tests/unit/style/stylist.rs
@@ -45,7 +45,7 @@ fn get_mock_rules(css_selectors: &[&str]) -> (Vec<Vec<Rule>>, SharedRwLock) {
         let guard = shared_lock.read();
         let rule = locked.read_with(&guard);
         rule.selectors.0.iter().map(|s| {
-            Rule::new(s.clone(), locked.clone(), i)
+            Rule::new(s.selector.clone(), s.hashes.clone(), locked.clone(), i)
         }).collect()
     }).collect(), shared_lock)
 }
@@ -68,7 +68,7 @@ fn parse_selectors(selectors: &[&str]) -> Vec<Selector<SelectorImpl>> {
              .map(|x| SelectorParser::parse_author_origin_no_namespace(x).unwrap().0
                                                                          .into_iter()
                                                                          .nth(0)
-                                                                         .unwrap())
+                                                                         .unwrap().selector)
              .collect()
 }
 
@@ -126,7 +126,6 @@ fn test_revalidation_selectors() {
         "p:first-child span",
     ]).into_iter()
       .filter(|s| needs_revalidation(&s))
-      .map(|s| s.inner.complex)
       .collect::<Vec<_>>();
 
     let reference = parse_selectors(&[
@@ -167,7 +166,6 @@ fn test_revalidation_selectors() {
         // Selectors in the ancestor chain (needed for cousin sharing).
         "p:first-child span",
     ]).into_iter()
-      .map(|s| s.inner.complex)
       .collect::<Vec<_>>();
 
     assert_eq!(test.len(), reference.len());
@@ -189,22 +187,22 @@ fn test_rule_ordering_same_specificity() {
 #[test]
 fn test_get_id_name() {
     let (rules_list, _) = get_mock_rules(&[".intro", "#top"]);
-    assert_eq!(selector_map::get_id_name(&rules_list[0][0].selector.inner), None);
-    assert_eq!(selector_map::get_id_name(&rules_list[1][0].selector.inner), Some(Atom::from("top")));
+    assert_eq!(selector_map::get_id_name(rules_list[0][0].selector.iter()), None);
+    assert_eq!(selector_map::get_id_name(rules_list[1][0].selector.iter()), Some(Atom::from("top")));
 }
 
 #[test]
 fn test_get_class_name() {
     let (rules_list, _) = get_mock_rules(&[".intro.foo", "#top"]);
-    assert_eq!(selector_map::get_class_name(&rules_list[0][0].selector.inner), Some(Atom::from("foo")));
-    assert_eq!(selector_map::get_class_name(&rules_list[1][0].selector.inner), None);
+    assert_eq!(selector_map::get_class_name(rules_list[0][0].selector.iter()), Some(Atom::from("foo")));
+    assert_eq!(selector_map::get_class_name(rules_list[1][0].selector.iter()), None);
 }
 
 #[test]
 fn test_get_local_name() {
     let (rules_list, _) = get_mock_rules(&["img.foo", "#top", "IMG", "ImG"]);
     let check = |i: usize, names: Option<(&str, &str)>| {
-        assert!(selector_map::get_local_name(&rules_list[i][0].selector.inner)
+        assert!(selector_map::get_local_name(rules_list[i][0].selector.iter())
                 == names.map(|(name, lower_name)| LocalNameSelector {
                         name: LocalName::from(name),
                         lower_name: LocalName::from(lower_name) }))