Report unexpected attribute selector tokens (bug 1384216).

components/selectors/parser.rs

@@ -55,7 +55,7 @@ pub enum SelectorParseError<'i, T> {
     NegationSelectorComponentNotLocalName,
     EmptySelector,
     NonSimpleSelectorInNegation,
-    UnexpectedTokenInAttributeSelector,
+    UnexpectedTokenInAttributeSelector(Token<'i>),
     PseudoElementExpectedColon,
     PseudoElementExpectedIdent,
     UnsupportedPseudoClassOrElement(CowRcStr<'i>),
@@ -1292,10 +1292,7 @@ fn parse_attribute_selector<'i, 't, P, E, Impl>(parser: &P, input: &mut CssParse
         }
     }
 
-    let operator;
+    let operator = match input.next() {
-    let value;
-    let never_matches;
-    match input.next() {
         // [foo]
         Err(_) => {
             let local_name_lower = to_ascii_lowercase(&local_name).as_ref().into();
@@ -1317,43 +1314,33 @@ fn parse_attribute_selector<'i, 't, P, E, Impl>(parser: &P, input: &mut CssParse
         }
 
         // [foo=bar]
-        Ok(&Token::Delim('=')) => {
+        Ok(&Token::Delim('=')) => AttrSelectorOperator::Equal,
-            value = input.expect_ident_or_string()?.clone();
-            never_matches = false;
-            operator = AttrSelectorOperator::Equal;
-        }
         // [foo~=bar]
-        Ok(&Token::IncludeMatch) => {
+        Ok(&Token::IncludeMatch) => AttrSelectorOperator::Includes,
-            value = input.expect_ident_or_string()?.clone();
-            never_matches = value.is_empty() || value.contains(SELECTOR_WHITESPACE);
-            operator = AttrSelectorOperator::Includes;
-        }
         // [foo|=bar]
-        Ok(&Token::DashMatch) => {
+        Ok(&Token::DashMatch) => AttrSelectorOperator::DashMatch,
-            value = input.expect_ident_or_string()?.clone();
-            never_matches = false;
-            operator = AttrSelectorOperator::DashMatch;
-        }
         // [foo^=bar]
-        Ok(&Token::PrefixMatch) => {
+        Ok(&Token::PrefixMatch) => AttrSelectorOperator::Prefix,
-            value = input.expect_ident_or_string()?.clone();
-            never_matches = value.is_empty();
-            operator = AttrSelectorOperator::Prefix;
-        }
         // [foo*=bar]
-        Ok(&Token::SubstringMatch) => {
+        Ok(&Token::SubstringMatch) => AttrSelectorOperator::Substring,
-            value = input.expect_ident_or_string()?.clone();
-            never_matches = value.is_empty();
-            operator = AttrSelectorOperator::Substring;
-        }
         // [foo$=bar]
-        Ok(&Token::SuffixMatch) => {
+        Ok(&Token::SuffixMatch) => AttrSelectorOperator::Suffix,
-            value = input.expect_ident_or_string()?.clone();
+        Ok(t) => return Err(SelectorParseError::UnexpectedTokenInAttributeSelector(t.clone()).into())
-            never_matches = value.is_empty();
+    };
-            operator = AttrSelectorOperator::Suffix;
+
+    let value = input.expect_ident_or_string()?.clone();
+    let never_matches = match operator {
+        AttrSelectorOperator::Equal |
+        AttrSelectorOperator::DashMatch => false,
+
+        AttrSelectorOperator::Includes => {
+            value.is_empty() || value.contains(SELECTOR_WHITESPACE)
         }
-        _ => return Err(SelectorParseError::UnexpectedTokenInAttributeSelector.into())
+
-    }
+        AttrSelectorOperator::Prefix |
+        AttrSelectorOperator::Substring |
+        AttrSelectorOperator::Suffix => value.is_empty()
+    };
 
     let mut case_sensitivity = parse_attribute_flags(input)?;
 

ports/geckolib/error_reporter.rs

@@ -250,6 +250,9 @@ fn extract_error_params<'a>(err: ParseError<'a>) -> Option<ErrorParams<'a>> {
                 PropertyDeclarationParseError::InvalidValue(property, Some(e))))) =>
             (Some(ErrorString::Snippet(property.into())), Some(extract_value_error_param(e))),
 
+        CssParseError::Custom(SelectorParseError::UnexpectedTokenInAttributeSelector(t)) =>
+            (None, Some(ErrorString::UnexpectedToken(t))),
+
         CssParseError::Custom(SelectorParseError::UnsupportedPseudoClassOrElement(p)) =>
             (None, Some(ErrorString::Ident(p))),
 
@@ -330,6 +333,8 @@ impl<'a> ErrorHelpers<'a> for ContextualParseError<'a> {
                 (b"PEAtNSUnexpected\0", Action::Nothing),
             ContextualParseError::InvalidRule(_, ref err) => {
                 let prefix = match *err {
+                    CssParseError::Custom(SelectorParseError::UnexpectedTokenInAttributeSelector(_)) =>
+                        Some(&b"PEAttSelUnexpected\0"[..]),
                     CssParseError::Custom(SelectorParseError::UnsupportedPseudoClassOrElement(_)) =>
                         Some(&b"PEPseudoSelUnknown\0"[..]),
                     _ => None,