Rename SimpleSelector to Component.

MozReview-Commit-ID: JfaZpHSkG8h

components/selectors/matching.rs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 use bloom::BloomFilter;
-use parser::{CaseSensitivity, Combinator, ComplexSelector, LocalName};
-use parser::{SimpleSelector, Selector, SelectorInner, SelectorIter};
+use parser::{CaseSensitivity, Combinator, ComplexSelector, Component, LocalName};
+use parser::{Selector, SelectorInner, SelectorIter};
 use std::borrow::Borrow;
 use tree::Element;
 
@@ -297,7 +297,7 @@ fn matches_complex_selector_internal<E, F>(mut selector_iter: SelectorIter<E::Im
 /// Determines whether the given element matches the given single selector.
 #[inline]
 fn matches_simple_selector<E, F>(
-        selector: &SimpleSelector<E::Impl>,
+        selector: &Component<E::Impl>,
         element: &E,
         relations: &mut StyleRelations,
         flags_setter: &mut F)
@@ -317,108 +317,108 @@ fn matches_simple_selector<E, F>(
     }
 
     match *selector {
-        SimpleSelector::Combinator(_) => unreachable!(),
-        SimpleSelector::LocalName(LocalName { ref name, ref lower_name }) => {
+        Component::Combinator(_) => unreachable!(),
+        Component::LocalName(LocalName { ref name, ref lower_name }) => {
             let name = if element.is_html_element_in_html_document() { lower_name } else { name };
             element.get_local_name() == name.borrow()
         }
-        SimpleSelector::Namespace(ref namespace) => {
+        Component::Namespace(ref namespace) => {
             element.get_namespace() == namespace.url.borrow()
         }
         // TODO: case-sensitivity depends on the document type and quirks mode
-        SimpleSelector::ID(ref id) => {
+        Component::ID(ref id) => {
             relation_if!(element.get_id().map_or(false, |attr| attr == *id),
                          AFFECTED_BY_ID_SELECTOR)
         }
-        SimpleSelector::Class(ref class) => {
+        Component::Class(ref class) => {
             element.has_class(class)
         }
-        SimpleSelector::AttrExists(ref attr) => {
+        Component::AttrExists(ref attr) => {
             element.match_attr_has(attr)
         }
-        SimpleSelector::AttrEqual(ref attr, ref value, case_sensitivity) => {
+        Component::AttrEqual(ref attr, ref value, case_sensitivity) => {
             match case_sensitivity {
                 CaseSensitivity::CaseSensitive => element.match_attr_equals(attr, value),
                 CaseSensitivity::CaseInsensitive => element.match_attr_equals_ignore_ascii_case(attr, value),
             }
         }
-        SimpleSelector::AttrIncludes(ref attr, ref value) => {
+        Component::AttrIncludes(ref attr, ref value) => {
             element.match_attr_includes(attr, value)
         }
-        SimpleSelector::AttrDashMatch(ref attr, ref value) => {
+        Component::AttrDashMatch(ref attr, ref value) => {
             element.match_attr_dash(attr, value)
         }
-        SimpleSelector::AttrPrefixMatch(ref attr, ref value) => {
+        Component::AttrPrefixMatch(ref attr, ref value) => {
             element.match_attr_prefix(attr, value)
         }
-        SimpleSelector::AttrSubstringMatch(ref attr, ref value) => {
+        Component::AttrSubstringMatch(ref attr, ref value) => {
             element.match_attr_substring(attr, value)
         }
-        SimpleSelector::AttrSuffixMatch(ref attr, ref value) => {
+        Component::AttrSuffixMatch(ref attr, ref value) => {
             element.match_attr_suffix(attr, value)
         }
-        SimpleSelector::AttrIncludesNeverMatch(..) |
-        SimpleSelector::AttrPrefixNeverMatch(..) |
-        SimpleSelector::AttrSubstringNeverMatch(..) |
-        SimpleSelector::AttrSuffixNeverMatch(..) => {
+        Component::AttrIncludesNeverMatch(..) |
+        Component::AttrPrefixNeverMatch(..) |
+        Component::AttrSubstringNeverMatch(..) |
+        Component::AttrSuffixNeverMatch(..) => {
             false
         }
-        SimpleSelector::NonTSPseudoClass(ref pc) => {
+        Component::NonTSPseudoClass(ref pc) => {
             relation_if!(element.match_non_ts_pseudo_class(pc, relations, flags_setter),
                          AFFECTED_BY_STATE)
         }
-        SimpleSelector::FirstChild => {
+        Component::FirstChild => {
             relation_if!(matches_first_child(element, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::LastChild => {
+        Component::LastChild => {
             relation_if!(matches_last_child(element, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::OnlyChild => {
+        Component::OnlyChild => {
             relation_if!(matches_first_child(element, flags_setter) &&
                          matches_last_child(element, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::Root => {
+        Component::Root => {
             // We never share styles with an element with no parent, so no point
             // in creating a new StyleRelation.
             element.is_root()
         }
-        SimpleSelector::Empty => {
+        Component::Empty => {
             flags_setter(element, HAS_EMPTY_SELECTOR);
             relation_if!(element.is_empty(), AFFECTED_BY_EMPTY)
         }
-        SimpleSelector::NthChild(a, b) => {
+        Component::NthChild(a, b) => {
             relation_if!(matches_generic_nth_child(element, a, b, false, false, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::NthLastChild(a, b) => {
+        Component::NthLastChild(a, b) => {
             relation_if!(matches_generic_nth_child(element, a, b, false, true, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::NthOfType(a, b) => {
+        Component::NthOfType(a, b) => {
             relation_if!(matches_generic_nth_child(element, a, b, true, false, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::NthLastOfType(a, b) => {
+        Component::NthLastOfType(a, b) => {
             relation_if!(matches_generic_nth_child(element, a, b, true, true, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::FirstOfType => {
+        Component::FirstOfType => {
             relation_if!(matches_generic_nth_child(element, 0, 1, true, false, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::LastOfType => {
+        Component::LastOfType => {
             relation_if!(matches_generic_nth_child(element, 0, 1, true, true, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::OnlyOfType => {
+        Component::OnlyOfType => {
             relation_if!(matches_generic_nth_child(element, 0, 1, true, false, flags_setter) &&
                          matches_generic_nth_child(element, 0, 1, true, true, flags_setter),
                          AFFECTED_BY_CHILD_INDEX)
         }
-        SimpleSelector::Negation(ref negated) => {
+        Component::Negation(ref negated) => {
             !negated.iter().all(|s| {
                 match matches_complex_selector_internal(s.iter(),
                                                         element,