Bug 1506391 - Revert try -> r#try change.
authorEmilio Cobos Álvarez <emilio@crisal.io>
Sat, 10 Nov 2018 21:20:27 +0100
changeset 445809 8f4a9b61793ae1fed7ea246c42abc3df1cb8b1d8
parent 445808 49396130df4b33056d4d06748e1563834ed8f225
child 445810 06fcefb352f7c82fcff0506605f2f625e7608ce2
push id109772
push useremilio@crisal.io
push dateSun, 11 Nov 2018 01:42:26 +0000
treeherdermozilla-inbound@06fcefb352f7 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1506391
milestone65.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1506391 - Revert try -> r#try change. Since we're in an inconsistent state because mako files weren't updated, and it's really ugly.
servo/components/style/counter_style/mod.rs
servo/components/style/custom_properties.rs
servo/components/style/font_face.rs
servo/components/style/media_queries/media_condition.rs
servo/components/style/media_queries/media_feature_expression.rs
servo/components/style/media_queries/media_query.rs
servo/components/style/stylesheets/document_rule.rs
servo/components/style/stylesheets/rule_parser.rs
servo/components/style/stylesheets/supports_rule.rs
servo/components/style/stylesheets/viewport_rule.rs
servo/components/style/values/computed/font.rs
servo/components/style/values/generics/font.rs
servo/components/style/values/generics/grid.rs
servo/components/style/values/generics/mod.rs
servo/components/style/values/generics/rect.rs
servo/components/style/values/generics/size.rs
servo/components/style/values/generics/svg.rs
servo/components/style/values/generics/text.rs
servo/components/style/values/generics/url.rs
servo/components/style/values/mod.rs
servo/components/style/values/specified/align.rs
servo/components/style/values/specified/background.rs
servo/components/style/values/specified/basic_shape.rs
servo/components/style/values/specified/border.rs
servo/components/style/values/specified/box.rs
servo/components/style/values/specified/color.rs
servo/components/style/values/specified/column.rs
servo/components/style/values/specified/counters.rs
servo/components/style/values/specified/easing.rs
servo/components/style/values/specified/effects.rs
servo/components/style/values/specified/flex.rs
servo/components/style/values/specified/font.rs
servo/components/style/values/specified/gecko.rs
servo/components/style/values/specified/grid.rs
servo/components/style/values/specified/image.rs
servo/components/style/values/specified/length.rs
servo/components/style/values/specified/list.rs
servo/components/style/values/specified/mod.rs
servo/components/style/values/specified/motion.rs
servo/components/style/values/specified/outline.rs
servo/components/style/values/specified/position.rs
servo/components/style/values/specified/source_size_list.rs
servo/components/style/values/specified/svg.rs
servo/components/style/values/specified/text.rs
servo/components/style/values/specified/transform.rs
servo/components/style/values/specified/ui.rs
servo/components/style_traits/values.rs
--- a/servo/components/style/counter_style/mod.rs
+++ b/servo/components/style/counter_style/mod.rs
@@ -365,17 +365,17 @@ impl Parse for System {
     ) -> Result<Self, ParseError<'i>> {
         try_match_ident_ignore_ascii_case! { input,
             "cyclic" => Ok(System::Cyclic),
             "numeric" => Ok(System::Numeric),
             "alphabetic" => Ok(System::Alphabetic),
             "symbolic" => Ok(System::Symbolic),
             "additive" => Ok(System::Additive),
             "fixed" => {
-                let first_symbol_value = input.r#try(|i| Integer::parse(context, i)).ok();
+                let first_symbol_value = input.try(|i| Integer::parse(context, i)).ok();
                 Ok(System::Fixed { first_symbol_value: first_symbol_value })
             }
             "extends" => {
                 let other = parse_counter_style_name(input)?;
                 Ok(System::Extends(other))
             }
         }
     }
@@ -452,17 +452,17 @@ pub struct Negative(pub Symbol, pub Opti
 
 impl Parse for Negative {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         Ok(Negative(
             Symbol::parse(context, input)?,
-            input.r#try(|input| Symbol::parse(context, input)).ok(),
+            input.try(|input| Symbol::parse(context, input)).ok(),
         ))
     }
 }
 
 /// <https://drafts.csswg.org/css-counter-styles/#counter-style-range>
 ///
 /// Empty Vec represents 'auto'
 #[derive(Clone, Debug)]
@@ -478,17 +478,17 @@ pub enum CounterBound {
 }
 
 impl Parse for Ranges {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("auto"))
+            .try(|input| input.expect_ident_matching("auto"))
             .is_ok()
         {
             Ok(Ranges(Vec::new()))
         } else {
             input
                 .parse_comma_separated(|input| {
                     let opt_start = parse_bound(context, input)?;
                     let opt_end = parse_bound(context, input)?;
@@ -507,17 +507,17 @@ impl Parse for Ranges {
         }
     }
 }
 
 fn parse_bound<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
 ) -> Result<CounterBound, ParseError<'i>> {
-    if let Ok(integer) = input.r#try(|input| Integer::parse(context, input)) {
+    if let Ok(integer) = input.try(|input| Integer::parse(context, input)) {
         return Ok(CounterBound::Integer(integer));
     }
     input.expect_ident_matching("infinite")?;
     Ok(CounterBound::Infinite)
 }
 
 impl ToCss for Ranges {
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
@@ -551,17 +551,17 @@ where
 #[derive(Clone, Debug, ToCss)]
 pub struct Pad(pub Integer, pub Symbol);
 
 impl Parse for Pad {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        let pad_with = input.r#try(|input| Symbol::parse(context, input));
+        let pad_with = input.try(|input| Symbol::parse(context, input));
         let min_length = Integer::parse_non_negative(context, input)?;
         let pad_with = pad_with.or_else(|_| Symbol::parse(context, input))?;
         Ok(Pad(min_length, pad_with))
     }
 }
 
 /// <https://drafts.csswg.org/css-counter-styles/#counter-style-fallback>
 #[derive(Clone, Debug, ToCss)]
@@ -583,17 +583,17 @@ pub struct Symbols(#[css(iterable)] pub 
 
 impl Parse for Symbols {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let mut symbols = Vec::new();
         loop {
-            if let Ok(s) = input.r#try(|input| Symbol::parse(context, input)) {
+            if let Ok(s) = input.try(|input| Symbol::parse(context, input)) {
                 symbols.push(s)
             } else {
                 if symbols.is_empty() {
                     return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                 } else {
                     return Ok(Symbols(symbols));
                 }
             }
@@ -635,17 +635,17 @@ impl OneOrMoreSeparated for AdditiveTupl
     type S = Comma;
 }
 
 impl Parse for AdditiveTuple {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        let symbol = input.r#try(|input| Symbol::parse(context, input));
+        let symbol = input.try(|input| Symbol::parse(context, input));
         let weight = Integer::parse_non_negative(context, input)?;
         let symbol = symbol.or_else(|_| Symbol::parse(context, input))?;
         Ok(AdditiveTuple {
             weight: weight,
             symbol: symbol,
         })
     }
 }
@@ -668,17 +668,17 @@ pub enum SpeakAs {
 }
 
 impl Parse for SpeakAs {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let mut is_spell_out = false;
-        let result = input.r#try(|input| {
+        let result = input.try(|input| {
             let ident = input.expect_ident().map_err(|_| ())?;
             match_ignore_ascii_case! { &*ident,
                 "auto" => Ok(SpeakAs::Auto),
                 "bullets" => Ok(SpeakAs::Bullets),
                 "numbers" => Ok(SpeakAs::Numbers),
                 "words" => Ok(SpeakAs::Words),
                 "spell-out" => {
                     is_spell_out = true;
--- a/servo/components/style/custom_properties.rs
+++ b/servo/components/style/custom_properties.rs
@@ -548,33 +548,33 @@ fn parse_fallback<'i, 't>(input: &mut Pa
 fn parse_var_function<'i, 't>(
     input: &mut Parser<'i, 't>,
     references: Option<&mut VarOrEnvReferences>,
 ) -> Result<(), ParseError<'i>> {
     let name = input.expect_ident_cloned()?;
     let name = parse_name(&name).map_err(|()| {
         input.new_custom_error(SelectorParseErrorKind::UnexpectedIdent(name.clone()))
     })?;
-    if input.r#try(|input| input.expect_comma()).is_ok() {
+    if input.try(|input| input.expect_comma()).is_ok() {
         parse_fallback(input)?;
     }
     if let Some(refs) = references {
         refs.custom_property_references.insert(Atom::from(name));
     }
     Ok(())
 }
 
 fn parse_env_function<'i, 't>(
     input: &mut Parser<'i, 't>,
     references: Option<&mut VarOrEnvReferences>,
 ) -> Result<(), ParseError<'i>> {
     // TODO(emilio): This should be <custom-ident> per spec, but no other
     // browser does that, see https://github.com/w3c/csswg-drafts/issues/3262.
     input.expect_ident()?;
-    if input.r#try(|input| input.expect_comma()).is_ok() {
+    if input.try(|input| input.expect_comma()).is_ok() {
         parse_fallback(input)?;
     }
     if let Some(references) = references {
         references.references_environment = true;
     }
     Ok(())
 }
 
--- a/servo/components/style/font_face.rs
+++ b/servo/components/style/font_face.rs
@@ -115,17 +115,17 @@ macro_rules! impl_range {
     ($range:ident, $component:ident) => {
         impl Parse for $range {
             fn parse<'i, 't>(
                 context: &ParserContext,
                 input: &mut Parser<'i, 't>,
             ) -> Result<Self, ParseError<'i>> {
                 let first = $component::parse(context, input)?;
                 let second = input
-                    .r#try(|input| $component::parse(context, input))
+                    .try(|input| $component::parse(context, input))
                     .unwrap_or_else(|_| first.clone());
                 Ok($range(first, second))
             }
         }
         impl ToCss for $range {
             fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
             where
                 W: fmt::Write,
@@ -229,17 +229,17 @@ impl Parse for FontStyle {
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let style = SpecifiedFontStyle::parse(context, input)?;
         Ok(match style {
             GenericFontStyle::Normal => FontStyle::Normal,
             GenericFontStyle::Italic => FontStyle::Italic,
             GenericFontStyle::Oblique(angle) => {
                 let second_angle = input
-                    .r#try(|input| SpecifiedFontStyle::parse_angle(context, input))
+                    .try(|input| SpecifiedFontStyle::parse_angle(context, input))
                     .unwrap_or_else(|_| angle.clone());
 
                 FontStyle::Oblique(angle, second_angle)
             },
         })
     }
 }
 
@@ -375,29 +375,29 @@ impl<'a, 'b, 'i> AtRuleParser<'i> for Fo
 }
 
 impl Parse for Source {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Source, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_function_matching("local"))
+            .try(|input| input.expect_function_matching("local"))
             .is_ok()
         {
             return input
                 .parse_nested_block(|input| FamilyName::parse(context, input))
                 .map(Source::Local);
         }
 
         let url = SpecifiedUrl::parse(context, input)?;
 
         // Parsing optional format()
         let format_hints = if input
-            .r#try(|input| input.expect_function_matching("format"))
+            .try(|input| input.expect_function_matching("format"))
             .is_ok()
         {
             input.parse_nested_block(|input| {
                 input.parse_comma_separated(|input| Ok(input.expect_string()?.as_ref().to_owned()))
             })?
         } else {
             vec![]
         };
--- a/servo/components/style/media_queries/media_condition.rs
+++ b/servo/components/style/media_queries/media_condition.rs
@@ -109,17 +109,17 @@ impl MediaCondition {
 
         if is_negation {
             let inner_condition = Self::parse_in_parens(context, input)?;
             return Ok(MediaCondition::Not(Box::new(inner_condition)));
         }
 
         // ParenthesisBlock.
         let first_condition = Self::parse_paren_block(context, input)?;
-        let operator = match input.r#try(Operator::parse) {
+        let operator = match input.try(Operator::parse) {
             Ok(op) => op,
             Err(..) => return Ok(first_condition),
         };
 
         if allow_or == AllowOr::No && operator == Operator::Or {
             return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
         }
 
@@ -128,17 +128,17 @@ impl MediaCondition {
         conditions.push(Self::parse_in_parens(context, input)?);
 
         let delim = match operator {
             Operator::And => "and",
             Operator::Or => "or",
         };
 
         loop {
-            if input.r#try(|i| i.expect_ident_matching(delim)).is_err() {
+            if input.try(|i| i.expect_ident_matching(delim)).is_err() {
                 return Ok(MediaCondition::Operation(
                     conditions.into_boxed_slice(),
                     operator,
                 ));
             }
 
             conditions.push(Self::parse_in_parens(context, input)?);
         }
@@ -154,17 +154,17 @@ impl MediaCondition {
     }
 
     fn parse_paren_block<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         input.parse_nested_block(|input| {
             // Base case.
-            if let Ok(inner) = input.r#try(|i| Self::parse(context, i)) {
+            if let Ok(inner) = input.try(|i| Self::parse(context, i)) {
                 return Ok(MediaCondition::InParens(Box::new(inner)));
             }
             let expr = MediaFeatureExpression::parse_in_parenthesis_block(context, input)?;
             Ok(MediaCondition::Feature(expr))
         })
     }
 
     /// Whether this condition matches the device and quirks mode.
--- a/servo/components/style/media_queries/media_feature_expression.rs
+++ b/servo/components/style/media_queries/media_feature_expression.rs
@@ -216,24 +216,24 @@ fn consume_operation_or_colon(input: &mu
             Token::Colon => return Ok(None),
             Token::Delim(oper) => oper,
             _ => return Err(()),
         }
     };
     Ok(Some(match first_delim {
         '=' => Operator::Equal,
         '>' => {
-            if input.r#try(|i| i.expect_delim('=')).is_ok() {
+            if input.try(|i| i.expect_delim('=')).is_ok() {
                 Operator::GreaterThanEqual
             } else {
                 Operator::GreaterThan
             }
         },
         '<' => {
-            if input.r#try(|i| i.expect_delim('=')).is_ok() {
+            if input.try(|i| i.expect_delim('=')).is_ok() {
                 Operator::LessThanEqual
             } else {
                 Operator::LessThan
             }
         },
         _ => return Err(()),
     }))
 }
@@ -345,17 +345,17 @@ impl MediaFeatureExpression {
 
             if range.is_some() && !feature.allows_ranges() {
                 return Err(location.new_custom_error(
                     StyleParseErrorKind::MediaQueryExpectedFeatureName(ident.clone()),
                 ));
             }
         }
 
-        let operator = input.r#try(consume_operation_or_colon);
+        let operator = input.try(consume_operation_or_colon);
         let operator = match operator {
             Err(..) => {
                 // If there's no colon, this is a media query of the
                 // form '(<feature>)', that is, there's no value
                 // specified.
                 //
                 // Gecko doesn't allow ranged expressions without a
                 // value, so just reject them here too.
--- a/servo/components/style/media_queries/media_query.rs
+++ b/servo/components/style/media_queries/media_query.rs
@@ -120,27 +120,27 @@ impl MediaQuery {
     /// Parse a media query given css input.
     ///
     /// Returns an error if any of the expressions is unknown.
     pub fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let (qualifier, explicit_media_type) = input
-            .r#try(|input| -> Result<_, ()> {
-                let qualifier = input.r#try(Qualifier::parse).ok();
+            .try(|input| -> Result<_, ()> {
+                let qualifier = input.try(Qualifier::parse).ok();
                 let ident = input.expect_ident().map_err(|_| ())?;
                 let media_type = MediaQueryType::parse(&ident)?;
                 Ok((qualifier, Some(media_type)))
             })
             .unwrap_or_default();
 
         let condition = if explicit_media_type.is_none() {
             Some(MediaCondition::parse(context, input)?)
-        } else if input.r#try(|i| i.expect_ident_matching("and")).is_ok() {
+        } else if input.try(|i| i.expect_ident_matching("and")).is_ok() {
             Some(MediaCondition::parse_disallow_or(context, input)?)
         } else {
             None
         };
 
         let media_type = explicit_media_type.unwrap_or(MediaQueryType::All);
         Ok(Self {
             qualifier,
--- a/servo/components/style/stylesheets/document_rule.rs
+++ b/servo/components/style/stylesheets/document_rule.rs
@@ -130,17 +130,17 @@ macro_rules! parse_quoted_or_unquoted_st
 }
 
 impl DocumentMatchingFunction {
     /// Parse a URL matching function for a`@document` rule's condition.
     pub fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(url) = input.r#try(|input| CssUrl::parse(context, input)) {
+        if let Ok(url) = input.try(|input| CssUrl::parse(context, input)) {
             return Ok(DocumentMatchingFunction::Url(url));
         }
 
         let location = input.current_source_location();
         let function = input.expect_function()?.clone();
         match_ignore_ascii_case! { &function,
             "url-prefix" => {
                 parse_quoted_or_unquoted_string!(input, DocumentMatchingFunction::UrlPrefix)
--- a/servo/components/style/stylesheets/rule_parser.rs
+++ b/servo/components/style/stylesheets/rule_parser.rs
@@ -197,17 +197,17 @@ impl<'a, 'i> AtRuleParser<'i> for TopLev
                 let prelude = AtRuleNonBlockPrelude::Import(url, media);
                 return Ok(AtRuleType::WithoutBlock(prelude));
             },
             "namespace" => {
                 if !self.check_state(State::Namespaces) {
                     return Err(input.new_custom_error(StyleParseErrorKind::UnexpectedNamespaceRule))
                 }
 
-                let prefix = input.r#try(|i| i.expect_ident_cloned())
+                let prefix = input.try(|i| i.expect_ident_cloned())
                                   .map(|s| Prefix::from(s.as_ref())).ok();
                 let maybe_namespace = match input.expect_url_or_string() {
                     Ok(url_or_string) => url_or_string,
                     Err(BasicParseError { kind: BasicParseErrorKind::UnexpectedToken(t), location }) => {
                         return Err(location.new_custom_error(StyleParseErrorKind::UnexpectedTokenWithinNamespace(t)))
                     }
                     Err(e) => return Err(e.into()),
                 };
--- a/servo/components/style/stylesheets/supports_rule.rs
+++ b/servo/components/style/stylesheets/supports_rule.rs
@@ -98,17 +98,17 @@ pub enum SupportsCondition {
     FutureSyntax(String),
 }
 
 impl SupportsCondition {
     /// Parse a condition
     ///
     /// <https://drafts.csswg.org/css-conditional/#supports_condition>
     pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("not")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("not")).is_ok() {
             let inner = SupportsCondition::parse_in_parens(input)?;
             return Ok(SupportsCondition::Not(Box::new(inner)));
         }
 
         let in_parens = SupportsCondition::parse_in_parens(input)?;
 
         let location = input.current_source_location();
         let (keyword, wrapper) = match input.next() {
@@ -124,17 +124,17 @@ impl SupportsCondition {
             Ok(t) => return Err(location.new_unexpected_token_error(t.clone())),
         };
 
         let mut conditions = Vec::with_capacity(2);
         conditions.push(in_parens);
         loop {
             conditions.push(SupportsCondition::parse_in_parens(input)?);
             if input
-                .r#try(|input| input.expect_ident_matching(keyword))
+                .try(|input| input.expect_ident_matching(keyword))
                 .is_err()
             {
                 // Did not find the expected keyword.
                 // If we found some other token, it will be rejected by
                 // `Parser::parse_entirely` somewhere up the stack.
                 return Ok(wrapper(conditions));
             }
         }
@@ -170,30 +170,30 @@ impl SupportsCondition {
             }
         }
     }
 
     /// <https://drafts.csswg.org/css-conditional-3/#supports_condition_in_parens>
     fn parse_in_parens<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
         // Whitespace is normally taken care of in `Parser::next`,
         // but we want to not include it in `pos` for the SupportsCondition::FutureSyntax cases.
-        while input.r#try(Parser::expect_whitespace).is_ok() {}
+        while input.try(Parser::expect_whitespace).is_ok() {}
         let pos = input.position();
         let location = input.current_source_location();
         // FIXME: remove clone() when lifetimes are non-lexical
         match input.next()?.clone() {
             Token::ParenthesisBlock => {
                 let nested =
-                    input.r#try(|input| input.parse_nested_block(parse_condition_or_declaration));
+                    input.try(|input| input.parse_nested_block(parse_condition_or_declaration));
                 if nested.is_ok() {
                     return nested;
                 }
             },
             Token::Function(ident) => {
-                let nested = input.r#try(|input| {
+                let nested = input.try(|input| {
                     input.parse_nested_block(|input| {
                         SupportsCondition::parse_functional(&ident, input)
                     })
                 });
                 if nested.is_ok() {
                     return nested;
                 }
             },
@@ -235,17 +235,17 @@ fn eval_moz_bool_pref(_: &CStr, _: &Pars
     false
 }
 
 /// supports_condition | declaration
 /// <https://drafts.csswg.org/css-conditional/#dom-css-supports-conditiontext-conditiontext>
 pub fn parse_condition_or_declaration<'i, 't>(
     input: &mut Parser<'i, 't>,
 ) -> Result<SupportsCondition, ParseError<'i>> {
-    if let Ok(condition) = input.r#try(SupportsCondition::parse) {
+    if let Ok(condition) = input.try(SupportsCondition::parse) {
         Ok(SupportsCondition::Parenthesized(Box::new(condition)))
     } else {
         Declaration::parse(input).map(SupportsCondition::Declaration)
     }
 }
 
 impl ToCss for SupportsCondition {
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
@@ -413,14 +413,14 @@ impl Declaration {
                 let id =
                     PropertyId::parse(&prop, context).map_err(|_| input.new_custom_error(()))?;
 
                 let mut declarations = SourcePropertyDeclaration::new();
                 input.parse_until_before(Delimiter::Bang, |input| {
                     PropertyDeclaration::parse_into(&mut declarations, id, &context, input)
                         .map_err(|_| input.new_custom_error(()))
                 })?;
-                let _ = input.r#try(parse_important);
+                let _ = input.try(parse_important);
                 Ok(())
             })
             .is_ok()
     }
 }
--- a/servo/components/style/stylesheets/viewport_rule.rs
+++ b/servo/components/style/stylesheets/viewport_rule.rs
@@ -260,17 +260,17 @@ impl ToCss for ViewportDescriptorDeclara
     }
 }
 
 fn parse_shorthand<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
 ) -> Result<(ViewportLength, ViewportLength), ParseError<'i>> {
     let min = ViewportLength::parse(context, input)?;
-    match input.r#try(|i| ViewportLength::parse(context, i)) {
+    match input.try(|i| ViewportLength::parse(context, i)) {
         Err(_) => Ok((min.clone(), min)),
         Ok(max) => Ok((min, max)),
     }
 }
 
 impl<'a, 'b, 'i> AtRuleParser<'i> for ViewportRuleParser<'a, 'b> {
     type PreludeNoBlock = ();
     type PreludeBlock = ();
@@ -284,34 +284,34 @@ impl<'a, 'b, 'i> DeclarationParser<'i> f
 
     fn parse_value<'t>(
         &mut self,
         name: CowRcStr<'i>,
         input: &mut Parser<'i, 't>,
     ) -> Result<Vec<ViewportDescriptorDeclaration>, ParseError<'i>> {
         macro_rules! declaration {
             ($declaration:ident($parse:expr)) => {
-                declaration!($declaration(value: r#try!($parse(input)),
-                                          important: input.r#try(parse_important).is_ok()))
+                declaration!($declaration(value: try!($parse(input)),
+                                          important: input.try(parse_important).is_ok()))
             };
             ($declaration:ident(value: $value:expr, important: $important:expr)) => {
                 ViewportDescriptorDeclaration::new(
                     self.context.stylesheet_origin,
                     ViewportDescriptor::$declaration($value),
                     $important)
             }
         }
 
         macro_rules! ok {
             ($declaration:ident($parse:expr)) => {
                 Ok(vec![declaration!($declaration($parse))])
             };
             (shorthand -> [$min:ident, $max:ident]) => {{
                 let shorthand = parse_shorthand(self.context, input)?;
-                let important = input.r#try(parse_important).is_ok();
+                let important = input.try(parse_important).is_ok();
 
                 Ok(vec![
                     declaration!($min(value: shorthand.0, important: important)),
                     declaration!($max(value: shorthand.1, important: important)),
                 ])
             }};
         }
 
--- a/servo/components/style/values/computed/font.rs
+++ b/servo/components/style/values/computed/font.rs
@@ -369,17 +369,17 @@ impl SingleFontFamily {
         SingleFontFamily::FamilyName(FamilyName {
             name: input,
             syntax: FamilyNameSyntax::Quoted,
         })
     }
 
     /// Parse a font-family value
     pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
-        if let Ok(value) = input.r#try(|i| i.expect_string_cloned()) {
+        if let Ok(value) = input.try(|i| i.expect_string_cloned()) {
             return Ok(SingleFontFamily::FamilyName(FamilyName {
                 name: Atom::from(&*value),
                 syntax: FamilyNameSyntax::Quoted,
             }));
         }
         let first_ident = input.expect_ident()?.clone();
 
         // FIXME(bholley): The fast thing to do here would be to look up the
@@ -414,17 +414,17 @@ impl SingleFontFamily {
 
         // These keywords are not allowed by themselves.
         // The only way this value can be valid with with another keyword.
         if css_wide_keyword {
             let ident = input.expect_ident()?;
             value.push(' ');
             value.push_str(&ident);
         }
-        while let Ok(ident) = input.r#try(|i| i.expect_ident_cloned()) {
+        while let Ok(ident) = input.try(|i| i.expect_ident_cloned()) {
             value.push(' ');
             value.push_str(&ident);
         }
         let syntax = if value.starts_with(' ') || value.ends_with(' ') || value.contains("  ") {
             // For font family names which contains special white spaces, e.g.
             // `font-family: \ a\ \ b\ \ c\ ;`, it is tricky to serialize them
             // as identifiers correctly. Just mark them quoted so we don't need
             // to worry about them in serialization code.
--- a/servo/components/style/values/generics/font.rs
+++ b/servo/components/style/values/generics/font.rs
@@ -80,17 +80,17 @@ impl<T> FontSettings<T> {
 
 impl<T: Parse> Parse for FontSettings<T> {
     /// https://drafts.csswg.org/css-fonts-4/#descdef-font-face-font-feature-settings
     /// https://drafts.csswg.org/css-fonts-4/#font-variation-settings-def
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("normal")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("normal")).is_ok() {
             return Ok(Self::normal());
         }
 
         Ok(FontSettings(
             input
                 .parse_comma_separated(|i| T::parse(context, i))?
                 .into_boxed_slice(),
         ))
--- a/servo/components/style/values/generics/grid.rs
+++ b/servo/components/style/values/generics/grid.rs
@@ -81,47 +81,47 @@ where
 }
 
 impl Parse for GridLine<specified::Integer> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let mut grid_line = Self::auto();
-        if input.r#try(|i| i.expect_ident_matching("auto")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
             return Ok(grid_line);
         }
 
         // <custom-ident> | [ <integer> && <custom-ident>? ] | [ span && [ <integer> || <custom-ident> ] ]
         // This <grid-line> horror is simply,
         // [ span? && [ <custom-ident> || <integer> ] ]
         // And, for some magical reason, "span" should be the first or last value and not in-between.
         let mut val_before_span = false;
 
         for _ in 0..3 {
             // Maximum possible entities for <grid-line>
             let location = input.current_source_location();
-            if input.r#try(|i| i.expect_ident_matching("span")).is_ok() {
+            if input.try(|i| i.expect_ident_matching("span")).is_ok() {
                 if grid_line.is_span {
                     return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                 }
 
                 if grid_line.line_num.is_some() || grid_line.ident.is_some() {
                     val_before_span = true;
                 }
 
                 grid_line.is_span = true;
-            } else if let Ok(i) = input.r#try(|i| specified::Integer::parse(context, i)) {
+            } else if let Ok(i) = input.try(|i| specified::Integer::parse(context, i)) {
                 // FIXME(emilio): Probably shouldn't reject if it's calc()...
                 if i.value() == 0 || val_before_span || grid_line.line_num.is_some() {
                     return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                 }
 
                 grid_line.line_num = Some(i);
-            } else if let Ok(name) = input.r#try(|i| i.expect_ident_cloned()) {
+            } else if let Ok(name) = input.try(|i| i.expect_ident_cloned()) {
                 if val_before_span || grid_line.ident.is_some() {
                     return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                 }
                 // NOTE(emilio): `span` is consumed above, so we only need to
                 // reject `auto`.
                 grid_line.ident = Some(CustomIdent::from_ident(location, &name, &["auto"])?);
             } else {
                 break;
@@ -370,17 +370,17 @@ pub enum RepeatCount<Integer> {
 
 impl Parse for RepeatCount<specified::Integer> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // Maximum number of repeat is 10000. The greater numbers should be clamped.
         const MAX_LINE: i32 = 10000;
-        if let Ok(mut i) = input.r#try(|i| specified::Integer::parse_positive(context, i)) {
+        if let Ok(mut i) = input.try(|i| specified::Integer::parse_positive(context, i)) {
             if i.value() > MAX_LINE {
                 i = specified::Integer::new(MAX_LINE);
             }
             Ok(RepeatCount::Number(i))
         } else {
             try_match_ident_ignore_ascii_case! { input,
                 "auto-fill" => Ok(RepeatCount::AutoFill),
                 "auto-fit" => Ok(RepeatCount::AutoFit),
@@ -600,24 +600,24 @@ impl Parse for LineNameList {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         input.expect_ident_matching("subgrid")?;
         let mut line_names = vec![];
         let mut fill_idx = None;
 
         loop {
-            let repeat_parse_result = input.r#try(|input| {
+            let repeat_parse_result = input.try(|input| {
                 input.expect_function_matching("repeat")?;
                 input.parse_nested_block(|input| {
                     let count = RepeatCount::parse(context, input)?;
                     input.expect_comma()?;
                     let mut names_list = vec![];
                     names_list.push(parse_line_names(input)?); // there should be at least one
-                    while let Ok(names) = input.r#try(parse_line_names) {
+                    while let Ok(names) = input.try(parse_line_names) {
                         names_list.push(names);
                     }
 
                     Ok((names_list, count))
                 })
             });
 
             if let Ok((mut names_list, count)) = repeat_parse_result {
@@ -638,17 +638,17 @@ impl Parse for LineNameList {
                         }
                         let names = names_list.pop().unwrap();
 
                         line_names.push(names);
                         fill_idx = Some(line_names.len() as u32 - 1);
                     },
                     _ => return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),
                 }
-            } else if let Ok(names) = input.r#try(parse_line_names) {
+            } else if let Ok(names) = input.try(parse_line_names) {
                 line_names.push(names);
             } else {
                 break;
             }
         }
 
         Ok(LineNameList {
             names: line_names.into_boxed_slice(),
--- a/servo/components/style/values/generics/mod.rs
+++ b/servo/components/style/values/generics/mod.rs
@@ -106,29 +106,26 @@ impl CounterStyleOrNone {
     }
 }
 
 impl Parse for CounterStyleOrNone {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(name) = input.r#try(|i| parse_counter_style_name(i)) {
+        if let Ok(name) = input.try(|i| parse_counter_style_name(i)) {
             return Ok(CounterStyleOrNone::Name(name));
         }
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(CounterStyleOrNone::None);
         }
-        if input
-            .r#try(|i| i.expect_function_matching("symbols"))
-            .is_ok()
-        {
+        if input.try(|i| i.expect_function_matching("symbols")).is_ok() {
             return input.parse_nested_block(|input| {
                 let symbols_type = input
-                    .r#try(|i| SymbolsType::parse(i))
+                    .try(|i| SymbolsType::parse(i))
                     .unwrap_or(SymbolsType::Symbolic);
                 let symbols = Symbols::parse(context, input)?;
                 // There must be at least two symbols for alphabetic or
                 // numeric system.
                 if (symbols_type == SymbolsType::Alphabetic ||
                     symbols_type == SymbolsType::Numeric) && symbols.0.len() < 2
                 {
                     return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
--- a/servo/components/style/values/generics/rect.rs
+++ b/servo/components/style/values/generics/rect.rs
@@ -45,34 +45,34 @@ where
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         parse: Parse,
     ) -> Result<Self, ParseError<'i>>
     where
         Parse: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>>,
     {
         let first = parse(context, input)?;
-        let second = if let Ok(second) = input.r#try(|i| parse(context, i)) {
+        let second = if let Ok(second) = input.try(|i| parse(context, i)) {
             second
         } else {
             // <first>
             return Ok(Self::new(
                 first.clone(),
                 first.clone(),
                 first.clone(),
                 first,
             ));
         };
-        let third = if let Ok(third) = input.r#try(|i| parse(context, i)) {
+        let third = if let Ok(third) = input.try(|i| parse(context, i)) {
             third
         } else {
             // <first> <second>
             return Ok(Self::new(first.clone(), second.clone(), first, second));
         };
-        let fourth = if let Ok(fourth) = input.r#try(|i| parse(context, i)) {
+        let fourth = if let Ok(fourth) = input.try(|i| parse(context, i)) {
             fourth
         } else {
             // <first> <second> <third>
             return Ok(Self::new(first, second.clone(), third, second));
         };
         // <first> <second> <third> <fourth>
         Ok(Self::new(first, second, third, fourth))
     }
--- a/servo/components/style/values/generics/size.rs
+++ b/servo/components/style/values/generics/size.rs
@@ -50,17 +50,17 @@ impl<L> Size<L> {
         parse_one: F,
     ) -> Result<Self, ParseError<'i>>
     where
         L: Clone,
         F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<L, ParseError<'i>>,
     {
         let first = parse_one(context, input)?;
         let second = input
-            .r#try(|i| parse_one(context, i))
+            .try(|i| parse_one(context, i))
             .unwrap_or_else(|_| first.clone());
         Ok(Self::new(first, second))
     }
 }
 
 impl<L> ToCss for Size<L>
 where
     L: ToCss + PartialEq,
--- a/servo/components/style/values/generics/svg.rs
+++ b/servo/components/style/values/generics/svg.rs
@@ -79,50 +79,50 @@ impl<ColorType, UrlPaintServer> SVGPaint
 
 /// Parse SVGPaint's fallback.
 /// fallback is keyword(none), Color or empty.
 /// <https://svgwg.org/svg2-draft/painting.html#SpecifyingPaint>
 fn parse_fallback<'i, 't, ColorType: Parse>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
 ) -> Option<Either<ColorType, None_>> {
-    if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+    if input.try(|i| i.expect_ident_matching("none")).is_ok() {
         Some(Either::Second(None_))
     } else {
-        if let Ok(color) = input.r#try(|i| ColorType::parse(context, i)) {
+        if let Ok(color) = input.try(|i| ColorType::parse(context, i)) {
             Some(Either::First(color))
         } else {
             None
         }
     }
 }
 
 impl<ColorType: Parse, UrlPaintServer: Parse> Parse for SVGPaint<ColorType, UrlPaintServer> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(url) = input.r#try(|i| UrlPaintServer::parse(context, i)) {
+        if let Ok(url) = input.try(|i| UrlPaintServer::parse(context, i)) {
             Ok(SVGPaint {
                 kind: SVGPaintKind::PaintServer(url),
                 fallback: parse_fallback(context, input),
             })
-        } else if let Ok(kind) = input.r#try(SVGPaintKind::parse_ident) {
+        } else if let Ok(kind) = input.try(SVGPaintKind::parse_ident) {
             if let SVGPaintKind::None = kind {
                 Ok(SVGPaint {
                     kind: kind,
                     fallback: None,
                 })
             } else {
                 Ok(SVGPaint {
                     kind: kind,
                     fallback: parse_fallback(context, input),
                 })
             }
-        } else if let Ok(color) = input.r#try(|i| ColorType::parse(context, i)) {
+        } else if let Ok(color) = input.try(|i| ColorType::parse(context, i)) {
             Ok(SVGPaint {
                 kind: SVGPaintKind::Color(color),
                 fallback: None,
             })
         } else {
             Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
         }
     }
@@ -153,17 +153,17 @@ pub enum SvgLengthOrPercentageOrNumber<L
 /// since prevent converting to the length.
 impl<LengthOrPercentageType: Parse, NumberType: Parse> Parse
     for SvgLengthOrPercentageOrNumber<LengthOrPercentageType, NumberType>
 {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(num) = input.r#try(|i| NumberType::parse(context, i)) {
+        if let Ok(num) = input.try(|i| NumberType::parse(context, i)) {
             return Ok(SvgLengthOrPercentageOrNumber::Number(num));
         }
 
         let lop = LengthOrPercentageType::parse(context, input)?;
         Ok(SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop))
     }
 }
 
--- a/servo/components/style/values/generics/text.rs
+++ b/servo/components/style/values/generics/text.rs
@@ -53,17 +53,17 @@ impl<Value> Spacing<Value> {
     pub fn parse_with<'i, 't, F>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         parse: F,
     ) -> Result<Self, ParseError<'i>>
     where
         F: FnOnce(&ParserContext, &mut Parser<'i, 't>) -> Result<Value, ParseError<'i>>,
     {
-        if input.r#try(|i| i.expect_ident_matching("normal")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("normal")).is_ok() {
             return Ok(Spacing::Normal);
         }
         parse(context, input).map(Spacing::Value)
     }
 
     /// Returns the spacing value, if not `normal`.
     #[inline]
     pub fn value(&self) -> Option<&Value> {
--- a/servo/components/style/values/generics/url.rs
+++ b/servo/components/style/values/generics/url.rs
@@ -39,15 +39,15 @@ impl<Url> UrlOrNone<Url> {
 impl<Url> Parse for UrlOrNone<Url>
 where
     Url: Parse,
 {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<UrlOrNone<Url>, ParseError<'i>> {
-        if let Ok(url) = input.r#try(|input| Url::parse(context, input)) {
+        if let Ok(url) = input.try(|input| Url::parse(context, input)) {
             return Ok(UrlOrNone::Url(url));
         }
         input.expect_ident_matching("none")?;
         Ok(UrlOrNone::None)
     }
 }
--- a/servo/components/style/values/mod.rs
+++ b/servo/components/style/values/mod.rs
@@ -150,17 +150,17 @@ impl<A: Debug, B: Debug> Debug for Eithe
     }
 }
 
 impl<A: Parse, B: Parse> Parse for Either<A, B> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Either<A, B>, ParseError<'i>> {
-        if let Ok(v) = input.r#try(|i| A::parse(context, i)) {
+        if let Ok(v) = input.try(|i| A::parse(context, i)) {
             Ok(Either::First(v))
         } else {
             B::parse(context, input).map(Either::Second)
         }
     }
 }
 
 /// <https://drafts.csswg.org/css-values-4/#custom-idents>
--- a/servo/components/style/values/specified/align.rs
+++ b/servo/components/style/values/specified/align.rs
@@ -190,35 +190,35 @@ impl ContentDistribution {
     pub fn parse<'i, 't>(
         input: &mut Parser<'i, 't>,
         axis: AxisDirection,
     ) -> Result<Self, ParseError<'i>> {
         // NOTE Please also update the `list_keywords` function below
         //      when this function is updated.
 
         // Try to parse normal first
-        if input.r#try(|i| i.expect_ident_matching("normal")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("normal")).is_ok() {
             return Ok(ContentDistribution::normal());
         }
 
         // Parse <baseline-position>, but only on the block axis.
         if axis == AxisDirection::Block {
-            if let Ok(value) = input.r#try(parse_baseline) {
+            if let Ok(value) = input.try(parse_baseline) {
                 return Ok(ContentDistribution::new(value));
             }
         }
 
         // <content-distribution>
-        if let Ok(value) = input.r#try(parse_content_distribution) {
+        if let Ok(value) = input.try(parse_content_distribution) {
             return Ok(ContentDistribution::new(value));
         }
 
         // <overflow-position>? <content-position>
         let overflow_position = input
-            .r#try(parse_overflow_position)
+            .try(parse_overflow_position)
             .unwrap_or(AlignFlags::empty());
 
         let content_position = try_match_ident_ignore_ascii_case! { input,
             "start" => AlignFlags::START,
             "end" => AlignFlags::END,
             "flex-start" => AlignFlags::FLEX_START,
             "flex-end" => AlignFlags::FLEX_END,
             "center" => AlignFlags::CENTER,
@@ -353,28 +353,28 @@ impl SelfAlignment {
     ) -> Result<Self, ParseError<'i>> {
         // NOTE Please also update the `list_keywords` function below
         //      when this function is updated.
 
         // <baseline-position>
         //
         // It's weird that this accepts <baseline-position>, but not
         // justify-content...
-        if let Ok(value) = input.r#try(parse_baseline) {
+        if let Ok(value) = input.try(parse_baseline) {
             return Ok(SelfAlignment(value));
         }
 
         // auto | normal | stretch
-        if let Ok(value) = input.r#try(parse_auto_normal_stretch) {
+        if let Ok(value) = input.try(parse_auto_normal_stretch) {
             return Ok(SelfAlignment(value));
         }
 
         // <overflow-position>? <self-position>
         let overflow_position = input
-            .r#try(parse_overflow_position)
+            .try(parse_overflow_position)
             .unwrap_or(AlignFlags::empty());
         let self_position = parse_self_position(input, axis)?;
         Ok(SelfAlignment(overflow_position | self_position))
     }
 
     fn list_keywords(f: KeywordsCollectFn, axis: AxisDirection) {
         list_baseline_keywords(f);
         list_auto_normal_stretch(f);
@@ -479,27 +479,27 @@ impl Parse for AlignItems {
     fn parse<'i, 't>(
         _: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // NOTE Please also update `impl SpecifiedValueInfo` below when
         //      this function is updated.
 
         // <baseline-position>
-        if let Ok(baseline) = input.r#try(parse_baseline) {
+        if let Ok(baseline) = input.try(parse_baseline) {
             return Ok(AlignItems(baseline));
         }
 
         // normal | stretch
-        if let Ok(value) = input.r#try(parse_normal_stretch) {
+        if let Ok(value) = input.try(parse_normal_stretch) {
             return Ok(AlignItems(value));
         }
         // <overflow-position>? <self-position>
         let overflow = input
-            .r#try(parse_overflow_position)
+            .try(parse_overflow_position)
             .unwrap_or(AlignFlags::empty());
         let self_position = parse_self_position(input, AxisDirection::Block)?;
         Ok(AlignItems(self_position | overflow))
     }
 }
 
 impl SpecifiedValueInfo for AlignItems {
     fn collect_completion_keywords(f: KeywordsCollectFn) {
@@ -537,33 +537,33 @@ impl Parse for JustifyItems {
     ) -> Result<Self, ParseError<'i>> {
         // NOTE Please also update `impl SpecifiedValueInfo` below when
         //      this function is updated.
 
         // <baseline-position>
         //
         // It's weird that this accepts <baseline-position>, but not
         // justify-content...
-        if let Ok(baseline) = input.r#try(parse_baseline) {
+        if let Ok(baseline) = input.try(parse_baseline) {
             return Ok(JustifyItems(baseline));
         }
 
         // normal | stretch
-        if let Ok(value) = input.r#try(parse_normal_stretch) {
+        if let Ok(value) = input.try(parse_normal_stretch) {
             return Ok(JustifyItems(value));
         }
 
         // legacy | [ legacy && [ left | right | center ] ]
-        if let Ok(value) = input.r#try(parse_legacy) {
+        if let Ok(value) = input.try(parse_legacy) {
             return Ok(JustifyItems(value));
         }
 
         // <overflow-position>? <self-position>
         let overflow = input
-            .r#try(parse_overflow_position)
+            .try(parse_overflow_position)
             .unwrap_or(AlignFlags::empty());
         let self_position = parse_self_position(input, AxisDirection::Inline)?;
         Ok(JustifyItems(overflow | self_position))
     }
 }
 
 impl SpecifiedValueInfo for JustifyItems {
     fn collect_completion_keywords(f: KeywordsCollectFn) {
@@ -709,17 +709,17 @@ fn parse_left_right_center<'i, 't>(
 }
 
 // legacy | [ legacy && [ left | right | center ] ]
 fn parse_legacy<'i, 't>(input: &mut Parser<'i, 't>) -> Result<AlignFlags, ParseError<'i>> {
     // NOTE Please also update the `list_legacy_keywords` function below
     //      when this function is updated.
     let flags = try_match_ident_ignore_ascii_case! { input,
         "legacy" => {
-            let flags = input.r#try(parse_left_right_center)
+            let flags = input.try(parse_left_right_center)
                 .unwrap_or(AlignFlags::empty());
 
             return Ok(AlignFlags::LEGACY | flags)
         }
         "left" => AlignFlags::LEFT,
         "right" => AlignFlags::RIGHT,
         "center" => AlignFlags::CENTER,
     };
--- a/servo/components/style/values/specified/background.rs
+++ b/servo/components/style/values/specified/background.rs
@@ -14,19 +14,19 @@ use style_traits::ParseError;
 /// A specified value for the `background-size` property.
 pub type BackgroundSize = GenericBackgroundSize<NonNegativeLengthOrPercentageOrAuto>;
 
 impl Parse for BackgroundSize {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(width) = input.r#try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i)) {
+        if let Ok(width) = input.try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i)) {
             let height = input
-                .r#try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i))
+                .try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i))
                 .unwrap_or(NonNegativeLengthOrPercentageOrAuto::auto());
             return Ok(GenericBackgroundSize::Explicit { width, height });
         }
         Ok(try_match_ident_ignore_ascii_case! { input,
             "cover" => GenericBackgroundSize::Cover,
             "contain" => GenericBackgroundSize::Contain,
         })
     }
@@ -101,12 +101,12 @@ impl Parse for BackgroundRepeat {
             Ok(h) => h,
             Err(()) => {
                 return Err(
                     input.new_custom_error(SelectorParseErrorKind::UnexpectedIdent(ident.clone()))
                 );
             },
         };
 
-        let vertical = input.r#try(BackgroundRepeatKeyword::parse).ok();
+        let vertical = input.try(BackgroundRepeatKeyword::parse).ok();
         Ok(BackgroundRepeat::Keywords(horizontal, vertical))
     }
 }
--- a/servo/components/style/values/specified/basic_shape.rs
+++ b/servo/components/style/values/specified/basic_shape.rs
@@ -65,66 +65,66 @@ fn is_clip_path_path_enabled(_: &ParserC
 
 impl Parse for ClippingShape {
     #[inline]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if is_clip_path_path_enabled(context) {
-            if let Ok(p) = input.r#try(|i| Path::parse(context, i)) {
+            if let Ok(p) = input.try(|i| Path::parse(context, i)) {
                 return Ok(ShapeSource::Path(p));
             }
         }
 
-        if let Ok(url) = input.r#try(|i| SpecifiedUrl::parse(context, i)) {
+        if let Ok(url) = input.try(|i| SpecifiedUrl::parse(context, i)) {
             return Ok(ShapeSource::ImageOrUrl(url));
         }
 
         Self::parse_common(context, input)
     }
 }
 
 impl Parse for FloatAreaShape {
     #[inline]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(image) = input.r#try(|i| Image::parse_with_cors_anonymous(context, i)) {
+        if let Ok(image) = input.try(|i| Image::parse_with_cors_anonymous(context, i)) {
             return Ok(ShapeSource::ImageOrUrl(image));
         }
 
         Self::parse_common(context, input)
     }
 }
 
 impl<ReferenceBox, ImageOrUrl> ShapeSource<BasicShape, ReferenceBox, ImageOrUrl>
 where
     ReferenceBox: Parse,
 {
     /// The internal parser for ShapeSource.
     fn parse_common<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(ShapeSource::None);
         }
 
         fn parse_component<U: Parse>(
             context: &ParserContext,
             input: &mut Parser,
             component: &mut Option<U>,
         ) -> bool {
             if component.is_some() {
                 return false; // already parsed this component
             }
 
-            *component = input.r#try(|i| U::parse(context, i)).ok();
+            *component = input.try(|i| U::parse(context, i)).ok();
             component.is_some()
         }
 
         let mut shape = None;
         let mut ref_box = None;
 
         while parse_component(context, input, &mut shape) ||
             parse_component(context, input, &mut ref_box)
@@ -142,17 +142,17 @@ where
     }
 }
 
 impl Parse for GeometryBox {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(shape_box) = input.r#try(|i| ShapeBox::parse(i)) {
+        if let Ok(shape_box) = input.try(|i| ShapeBox::parse(i)) {
             return Ok(GeometryBox::ShapeBox(shape_box));
         }
 
         try_match_ident_ignore_ascii_case! { input,
             "fill-box" => Ok(GeometryBox::FillBox),
             "stroke-box" => Ok(GeometryBox::StrokeBox),
             "view-box" => Ok(GeometryBox::ViewBox),
         }
@@ -192,17 +192,17 @@ impl Parse for InsetRect {
 
 impl InsetRect {
     /// Parse the inner function arguments of `inset()`
     fn parse_function_arguments<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let rect = Rect::parse_with(context, input, LengthOrPercentage::parse)?;
-        let round = if input.r#try(|i| i.expect_ident_matching("round")).is_ok() {
+        let round = if input.try(|i| i.expect_ident_matching("round")).is_ok() {
             Some(BorderRadius::parse(context, input)?)
         } else {
             None
         };
         Ok(generic::InsetRect {
             rect: rect,
             round: round,
         })
@@ -220,19 +220,19 @@ impl Parse for Circle {
 }
 
 impl Circle {
     fn parse_function_arguments<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let radius = input
-            .r#try(|i| ShapeRadius::parse(context, i))
+            .try(|i| ShapeRadius::parse(context, i))
             .unwrap_or_default();
-        let position = if input.r#try(|i| i.expect_ident_matching("at")).is_ok() {
+        let position = if input.try(|i| i.expect_ident_matching("at")).is_ok() {
             Position::parse(context, input)?
         } else {
             Position::center()
         };
 
         Ok(generic::Circle { radius, position })
     }
 }
@@ -265,24 +265,24 @@ impl Parse for Ellipse {
 }
 
 impl Ellipse {
     fn parse_function_arguments<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let (a, b) = input
-            .r#try(|i| -> Result<_, ParseError> {
+            .try(|i| -> Result<_, ParseError> {
                 Ok((
                     ShapeRadius::parse(context, i)?,
                     ShapeRadius::parse(context, i)?,
                 ))
             })
             .unwrap_or_default();
-        let position = if input.r#try(|i| i.expect_ident_matching("at")).is_ok() {
+        let position = if input.try(|i| i.expect_ident_matching("at")).is_ok() {
             Position::parse(context, input)?
         } else {
             Position::center()
         };
 
         Ok(generic::Ellipse {
             semiaxis_x: a,
             semiaxis_y: b,
@@ -310,17 +310,17 @@ impl ToCss for Ellipse {
     }
 }
 
 impl Parse for ShapeRadius {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(lop) = input.r#try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
+        if let Ok(lop) = input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
             return Ok(generic::ShapeRadius::Length(lop));
         }
 
         try_match_ident_ignore_ascii_case! { input,
             "closest-side" => Ok(generic::ShapeRadius::ClosestSide),
             "farthest-side" => Ok(generic::ShapeRadius::FarthestSide),
         }
     }
@@ -414,17 +414,17 @@ impl Parse for Polygon {
 
 impl Polygon {
     /// Parse the inner arguments of a `polygon` function.
     fn parse_function_arguments<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let fill = input
-            .r#try(|i| -> Result<_, ParseError> {
+            .try(|i| -> Result<_, ParseError> {
                 let fill = FillRule::parse(i)?;
                 i.expect_comma()?; // only eat the comma if there is something before it
                 Ok(fill)
             })
             .unwrap_or_default();
 
         let buf = input.parse_comma_separated(|i| {
             Ok(PolygonCoord(
@@ -452,17 +452,17 @@ impl Parse for Path {
 
 impl Path {
     /// Parse the inner arguments of a `path` function.
     fn parse_function_arguments<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let fill = input
-            .r#try(|i| -> Result<_, ParseError> {
+            .try(|i| -> Result<_, ParseError> {
                 let fill = FillRule::parse(i)?;
                 i.expect_comma()?;
                 Ok(fill)
             })
             .unwrap_or_default();
         let path = SVGPathData::parse(context, input)?;
         Ok(Path { fill, path })
     }
--- a/servo/components/style/values/specified/border.rs
+++ b/servo/components/style/values/specified/border.rs
@@ -53,17 +53,17 @@ pub type BorderSpacing = GenericBorderSp
 impl BorderSideWidth {
     /// Parses, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
         if let Ok(length) =
-            input.r#try(|i| Length::parse_non_negative_quirky(context, i, allow_quirks))
+            input.try(|i| Length::parse_non_negative_quirky(context, i, allow_quirks))
         {
             return Ok(BorderSideWidth::Length(length));
         }
         try_match_ident_ignore_ascii_case! { input,
             "thin" => Ok(BorderSideWidth::Thin),
             "medium" => Ok(BorderSideWidth::Medium),
             "thick" => Ok(BorderSideWidth::Thick),
         }
@@ -110,53 +110,53 @@ impl BorderImageSideWidth {
     }
 }
 
 impl Parse for BorderImageSideWidth {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("auto")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
             return Ok(GenericBorderImageSideWidth::Auto);
         }
 
-        if let Ok(len) = input.r#try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
+        if let Ok(len) = input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
             return Ok(GenericBorderImageSideWidth::Length(len));
         }
 
         let num = Number::parse_non_negative(context, input)?;
         Ok(GenericBorderImageSideWidth::Number(num))
     }
 }
 
 impl Parse for BorderImageSlice {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        let mut fill = input.r#try(|i| i.expect_ident_matching("fill")).is_ok();
+        let mut fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
         let offsets = Rect::parse_with(context, input, NumberOrPercentage::parse_non_negative)?;
         if !fill {
-            fill = input.r#try(|i| i.expect_ident_matching("fill")).is_ok();
+            fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
         }
         Ok(GenericBorderImageSlice {
             offsets: offsets,
             fill: fill,
         })
     }
 }
 
 impl Parse for BorderRadius {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let widths = Rect::parse_with(context, input, LengthOrPercentage::parse_non_negative)?;
-        let heights = if input.r#try(|i| i.expect_delim('/')).is_ok() {
+        let heights = if input.try(|i| i.expect_delim('/')).is_ok() {
             Rect::parse_with(context, input, LengthOrPercentage::parse_non_negative)?
         } else {
             widths.clone()
         };
 
         Ok(GenericBorderRadius {
             top_left: BorderCornerRadius::new(widths.0, heights.0),
             top_right: BorderCornerRadius::new(widths.1, heights.1),
@@ -231,15 +231,15 @@ impl BorderImageRepeat {
 }
 
 impl Parse for BorderImageRepeat {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let horizontal = BorderImageRepeatKeyword::parse(input)?;
-        let vertical = input.r#try(BorderImageRepeatKeyword::parse).ok();
+        let vertical = input.try(BorderImageRepeatKeyword::parse).ok();
         Ok(BorderImageRepeat(
             horizontal,
             vertical.unwrap_or(horizontal),
         ))
     }
 }
--- a/servo/components/style/values/specified/box.rs
+++ b/servo/components/style/values/specified/box.rs
@@ -305,17 +305,17 @@ impl Display {
 pub type VerticalAlign = GenericVerticalAlign<LengthOrPercentage>;
 
 impl Parse for VerticalAlign {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if let Ok(lop) =
-            input.r#try(|i| LengthOrPercentage::parse_quirky(context, i, AllowQuirks::Yes))
+            input.try(|i| LengthOrPercentage::parse_quirky(context, i, AllowQuirks::Yes))
         {
             return Ok(GenericVerticalAlign::Length(lop));
         }
 
         try_match_ident_ignore_ascii_case! { input,
             "baseline" => Ok(GenericVerticalAlign::Baseline),
             "sub" => Ok(GenericVerticalAlign::Sub),
             "super" => Ok(GenericVerticalAlign::Super),
@@ -336,17 +336,17 @@ impl Parse for VerticalAlign {
 pub type AnimationIterationCount = GenericAnimationIterationCount<Number>;
 
 impl Parse for AnimationIterationCount {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut ::cssparser::Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("infinite"))
+            .try(|input| input.expect_ident_matching("infinite"))
             .is_ok()
         {
             return Ok(GenericAnimationIterationCount::Infinite);
         }
 
         let number = Number::parse_non_negative(context, input)?;
         Ok(GenericAnimationIterationCount::Number(number))
     }
@@ -389,17 +389,17 @@ impl ToCss for AnimationName {
     }
 }
 
 impl Parse for AnimationName {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(name) = input.r#try(|input| KeyframesName::parse(context, input)) {
+        if let Ok(name) = input.try(|input| KeyframesName::parse(context, input)) {
             return Ok(AnimationName(Some(name)));
         }
 
         input.expect_ident_matching("none")?;
         Ok(AnimationName(None))
     }
 }
 
@@ -552,17 +552,17 @@ fn change_bits_for_maybe_property(ident:
 
 impl Parse for WillChange {
     /// auto | <animateable-feature>#
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<WillChange, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("auto"))
+            .try(|input| input.expect_ident_matching("auto"))
             .is_ok()
         {
             return Ok(WillChange::Auto);
         }
 
         let mut bits = WillChangeBits::empty();
         let custom_idents = input.parse_comma_separated(|i| {
             let location = i.current_source_location();
@@ -641,24 +641,24 @@ impl Parse for TouchAction {
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<TouchAction, ParseError<'i>> {
         try_match_ident_ignore_ascii_case! { input,
             "auto" => Ok(TouchAction::TOUCH_ACTION_AUTO),
             "none" => Ok(TouchAction::TOUCH_ACTION_NONE),
             "manipulation" => Ok(TouchAction::TOUCH_ACTION_MANIPULATION),
             "pan-x" => {
-                if input.r#try(|i| i.expect_ident_matching("pan-y")).is_ok() {
+                if input.try(|i| i.expect_ident_matching("pan-y")).is_ok() {
                     Ok(TouchAction::TOUCH_ACTION_PAN_X | TouchAction::TOUCH_ACTION_PAN_Y)
                 } else {
                     Ok(TouchAction::TOUCH_ACTION_PAN_X)
                 }
             },
             "pan-y" => {
-                if input.r#try(|i| i.expect_ident_matching("pan-x")).is_ok() {
+                if input.try(|i| i.expect_ident_matching("pan-x")).is_ok() {
                     Ok(TouchAction::TOUCH_ACTION_PAN_X | TouchAction::TOUCH_ACTION_PAN_Y)
                 } else {
                     Ok(TouchAction::TOUCH_ACTION_PAN_Y)
                 }
             },
         }
     }
 }
@@ -752,17 +752,17 @@ impl ToCss for Contain {
 
 impl Parse for Contain {
     /// none | strict | content | [ size || layout || style || paint ]
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Contain, ParseError<'i>> {
         let mut result = Contain::empty();
-        while let Ok(name) = input.r#try(|i| i.expect_ident_cloned()) {
+        while let Ok(name) = input.try(|i| i.expect_ident_cloned()) {
             let flag = match_ignore_ascii_case! { &name,
                 "size" => Some(Contain::SIZE),
                 "layout" => Some(Contain::LAYOUT),
                 "style" => Some(Contain::STYLE),
                 "paint" => Some(Contain::PAINT),
                 "strict" if result.is_empty() => return Ok(Contain::STRICT | Contain::STRICT_BITS),
                 "content" if result.is_empty() => return Ok(Contain::CONTENT | Contain::CONTENT_BITS),
                 "none" if result.is_empty() => return Ok(result),
@@ -789,17 +789,17 @@ impl Parse for Contain {
 /// A specified value for the `perspective` property.
 pub type Perspective = GenericPerspective<NonNegativeLength>;
 
 impl Parse for Perspective {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(GenericPerspective::None);
         }
         Ok(GenericPerspective::Length(NonNegativeLength::parse(
             context, input,
         )?))
     }
 }
 
--- a/servo/components/style/values/specified/color.rs
+++ b/servo/components/style/values/specified/color.rs
@@ -137,17 +137,17 @@ impl Parse for Color {
         // Currently we only store authored value for color keywords,
         // because all browsers serialize those values as keywords for
         // specified value.
         let start = input.state();
         let authored = input.expect_ident_cloned().ok();
         input.reset(&start);
 
         let compontent_parser = ColorComponentParser(&*context);
-        match input.r#try(|i| CSSParserColor::parse_with(&compontent_parser, i)) {
+        match input.try(|i| CSSParserColor::parse_with(&compontent_parser, i)) {
             Ok(value) => Ok(match value {
                 CSSParserColor::CurrentColor => Color::CurrentColor,
                 CSSParserColor::RGBA(rgba) => Color::Numeric {
                     parsed: rgba,
                     authored: authored.map(|s| s.to_ascii_lowercase().into_boxed_str()),
                 },
             }),
             Err(e) => {
@@ -240,17 +240,17 @@ impl Color {
     /// Parse a color, with quirks.
     ///
     /// <https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk>
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        input.r#try(|i| Self::parse(context, i)).or_else(|e| {
+        input.try(|i| Self::parse(context, i)).or_else(|e| {
             if !allow_quirks.allowed(context.quirks_mode) {
                 return Err(e);
             }
             Color::parse_quirky_color(input)
                 .map(Color::rgba)
                 .map_err(|_| e)
         })
     }
--- a/servo/components/style/values/specified/column.rs
+++ b/servo/components/style/values/specified/column.rs
@@ -13,16 +13,16 @@ use style_traits::ParseError;
 /// A specified type for `column-count` values.
 pub type ColumnCount = GenericColumnCount<PositiveInteger>;
 
 impl Parse for ColumnCount {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("auto")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
             return Ok(GenericColumnCount::Auto);
         }
         Ok(GenericColumnCount::Integer(PositiveInteger::parse(
             context, input,
         )?))
     }
 }
--- a/servo/components/style/values/specified/counters.rs
+++ b/servo/components/style/values/specified/counters.rs
@@ -47,33 +47,33 @@ impl Parse for CounterReset {
 }
 
 fn parse_counters<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
     default_value: i32,
 ) -> Result<Vec<CounterPair<Integer>>, ParseError<'i>> {
     if input
-        .r#try(|input| input.expect_ident_matching("none"))
+        .try(|input| input.expect_ident_matching("none"))
         .is_ok()
     {
         return Ok(vec![]);
     }
 
     let mut counters = Vec::new();
     loop {
         let location = input.current_source_location();
         let name = match input.next() {
             Ok(&Token::Ident(ref ident)) => CustomIdent::from_ident(location, ident, &["none"])?,
             Ok(t) => return Err(location.new_unexpected_token_error(t.clone())),
             Err(_) => break,
         };
 
         let value = input
-            .r#try(|input| Integer::parse(context, input))
+            .try(|input| Integer::parse(context, input))
             .unwrap_or(Integer::new(default_value));
         counters.push(CounterPair { name, value });
     }
 
     if !counters.is_empty() {
         Ok(counters)
     } else {
         Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
@@ -85,69 +85,69 @@ pub type Content = generics::Content<Spe
 
 /// The specified value for a content item in the `content` property.
 pub type ContentItem = generics::ContentItem<SpecifiedImageUrl>;
 
 impl Content {
     #[cfg(feature = "servo")]
     fn parse_counter_style(_: &ParserContext, input: &mut Parser) -> ListStyleType {
         input
-            .r#try(|input| {
+            .try(|input| {
                 input.expect_comma()?;
                 ListStyleType::parse(input)
             })
             .unwrap_or(ListStyleType::Decimal)
     }
 
     #[cfg(feature = "gecko")]
     fn parse_counter_style(context: &ParserContext, input: &mut Parser) -> CounterStyleOrNone {
         input
-            .r#try(|input| {
+            .try(|input| {
                 input.expect_comma()?;
                 CounterStyleOrNone::parse(context, input)
             })
             .unwrap_or(CounterStyleOrNone::decimal())
     }
 }
 
 impl Parse for Content {
     // normal | none | [ <string> | <counter> | open-quote | close-quote | no-open-quote |
     // no-close-quote ]+
     // TODO: <uri>, attr(<identifier>)
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(generics::Content::Normal);
         }
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(generics::Content::None);
         }
         #[cfg(feature = "gecko")]
         {
             if input
-                .r#try(|input| input.expect_ident_matching("-moz-alt-content"))
+                .try(|input| input.expect_ident_matching("-moz-alt-content"))
                 .is_ok()
             {
                 return Ok(generics::Content::MozAltContent);
             }
         }
 
         let mut content = vec![];
         loop {
             #[cfg(feature = "gecko")]
             {
-                if let Ok(url) = input.r#try(|i| SpecifiedImageUrl::parse(context, i)) {
+                if let Ok(url) = input.try(|i| SpecifiedImageUrl::parse(context, i)) {
                     content.push(generics::ContentItem::Url(url));
                     continue;
                 }
             }
             // FIXME: remove clone() when lifetimes are non-lexical
             match input.next().map(|t| t.clone()) {
                 Ok(Token::QuotedString(ref value)) => {
                     content.push(generics::ContentItem::String(
--- a/servo/components/style/values/specified/easing.rs
+++ b/servo/components/style/values/specified/easing.rs
@@ -16,20 +16,20 @@ use style_traits::{ParseError, StylePars
 /// A specified timing function.
 pub type TimingFunction = GenericTimingFunction<Integer, Number>;
 
 impl Parse for TimingFunction {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(keyword) = input.r#try(TimingKeyword::parse) {
+        if let Ok(keyword) = input.try(TimingKeyword::parse) {
             return Ok(GenericTimingFunction::Keyword(keyword));
         }
-        if let Ok(ident) = input.r#try(|i| i.expect_ident_cloned()) {
+        if let Ok(ident) = input.try(|i| i.expect_ident_cloned()) {
             let position = match_ignore_ascii_case! { &ident,
                 "step-start" => StepPosition::Start,
                 "step-end" => StepPosition::End,
                 _ => {
                     return Err(input.new_custom_error(
                         SelectorParseErrorKind::UnexpectedIdent(ident.clone())
                     ));
                 },
@@ -52,17 +52,17 @@ impl Parse for TimingFunction {
                     if x1.get() < 0.0 || x1.get() > 1.0 || x2.get() < 0.0 || x2.get() > 1.0 {
                         return Err(i.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                     }
 
                     Ok(GenericTimingFunction::CubicBezier { x1, y1, x2, y2 })
                 },
                 "steps" => {
                     let steps = Integer::parse_positive(context, i)?;
-                    let position = i.r#try(|i| {
+                    let position = i.try(|i| {
                         i.expect_comma()?;
                         StepPosition::parse(context, i)
                     }).unwrap_or(StepPosition::End);
 
                     // jump-none accepts a positive integer greater than 1.
                     // FIXME(emilio): The spec asks us to avoid rejecting it at parse
                     // time except until computed value time.
                     //
--- a/servo/components/style/values/specified/effects.rs
+++ b/servo/components/style/values/specified/effects.rs
@@ -104,45 +104,45 @@ impl Parse for BoxShadow {
     ) -> Result<Self, ParseError<'i>> {
         let mut lengths = None;
         let mut color = None;
         let mut inset = false;
 
         loop {
             if !inset {
                 if input
-                    .r#try(|input| input.expect_ident_matching("inset"))
+                    .try(|input| input.expect_ident_matching("inset"))
                     .is_ok()
                 {
                     inset = true;
                     continue;
                 }
             }
             if lengths.is_none() {
-                let value = input.r#try::<_, _, ParseError>(|i| {
+                let value = input.try::<_, _, ParseError>(|i| {
                     let horizontal = Length::parse(context, i)?;
                     let vertical = Length::parse(context, i)?;
                     let (blur, spread) = match i
-                        .r#try::<_, _, ParseError>(|i| Length::parse_non_negative(context, i))
+                        .try::<_, _, ParseError>(|i| Length::parse_non_negative(context, i))
                     {
                         Ok(blur) => {
-                            let spread = i.r#try(|i| Length::parse(context, i)).ok();
+                            let spread = i.try(|i| Length::parse(context, i)).ok();
                             (Some(blur.into()), spread)
                         },
                         Err(_) => (None, None),
                     };
                     Ok((horizontal, vertical, blur, spread))
                 });
                 if let Ok(value) = value {
                     lengths = Some(value);
                     continue;
                 }
             }
             if color.is_none() {
-                if let Ok(value) = input.r#try(|i| Color::parse(context, i)) {
+                if let Ok(value) = input.try(|i| Color::parse(context, i)) {
                     color = Some(value);
                     continue;
                 }
             }
             break;
         }
 
         let lengths =
@@ -189,17 +189,17 @@ impl ToComputedValue for BoxShadow {
 impl Parse for Filter {
     #[inline]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         #[cfg(feature = "gecko")]
         {
-            if let Ok(url) = input.r#try(|i| SpecifiedUrl::parse(context, i)) {
+            if let Ok(url) = input.try(|i| SpecifiedUrl::parse(context, i)) {
                 return Ok(GenericFilter::Url(url));
             }
         }
         let location = input.current_source_location();
         let function = match input.expect_function() {
             Ok(f) => f.clone(),
             Err(cssparser::BasicParseError {
                 kind: BasicParseErrorKind::UnexpectedToken(t),
@@ -248,22 +248,22 @@ impl Parse for Filter {
 }
 
 impl Parse for SimpleShadow {
     #[inline]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        let color = input.r#try(|i| Color::parse(context, i)).ok();
+        let color = input.try(|i| Color::parse(context, i)).ok();
         let horizontal = Length::parse(context, input)?;
         let vertical = Length::parse(context, input)?;
-        let blur = input.r#try(|i| Length::parse_non_negative(context, i)).ok();
+        let blur = input.try(|i| Length::parse_non_negative(context, i)).ok();
         let blur = blur.map(NonNegative::<Length>);
-        let color = color.or_else(|| input.r#try(|i| Color::parse(context, i)).ok());
+        let color = color.or_else(|| input.try(|i| Color::parse(context, i)).ok());
 
         Ok(SimpleShadow {
             color,
             horizontal,
             vertical,
             blur,
         })
     }
--- a/servo/components/style/values/specified/flex.rs
+++ b/servo/components/style/values/specified/flex.rs
@@ -20,17 +20,17 @@ pub type Width = crate::values::specifie
 /// A specified value for the `flex-basis` property.
 pub type FlexBasis = GenericFlexBasis<Width>;
 
 impl Parse for FlexBasis {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(width) = input.r#try(|i| Width::parse(context, i)) {
+        if let Ok(width) = input.try(|i| Width::parse(context, i)) {
             return Ok(GenericFlexBasis::Width(width));
         }
         try_match_ident_ignore_ascii_case! { input,
             "content" => Ok(GenericFlexBasis::Content),
         }
     }
 }
 
--- a/servo/components/style/values/specified/font.rs
+++ b/servo/components/style/values/specified/font.rs
@@ -112,17 +112,17 @@ impl FontWeight {
     }
 }
 
 impl Parse for FontWeight {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontWeight, ParseError<'i>> {
-        if let Ok(absolute) = input.r#try(|input| AbsoluteFontWeight::parse(context, input)) {
+        if let Ok(absolute) = input.try(|input| AbsoluteFontWeight::parse(context, input)) {
             return Ok(FontWeight::Absolute(absolute));
         }
 
         Ok(try_match_ident_ignore_ascii_case! { input,
             "bolder" => FontWeight::Bolder,
             "lighter" => FontWeight::Lighter,
         })
     }
@@ -185,17 +185,17 @@ impl AbsoluteFontWeight {
     }
 }
 
 impl Parse for AbsoluteFontWeight {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(number) = input.r#try(|input| Number::parse(context, input)) {
+        if let Ok(number) = input.try(|input| Number::parse(context, input)) {
             // We could add another AllowedNumericType value, but it doesn't
             // seem worth it just for a single property with such a weird range,
             // so we do the clamping here manually.
             if !number.was_calc() &&
                 (number.get() < MIN_FONT_WEIGHT || number.get() > MAX_FONT_WEIGHT)
             {
                 return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
             }
@@ -237,17 +237,17 @@ impl Parse for SpecifiedFontStyle {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         Ok(try_match_ident_ignore_ascii_case! { input,
             "normal" => generics::FontStyle::Normal,
             "italic" => generics::FontStyle::Italic,
             "oblique" => {
-                let angle = input.r#try(|input| Self::parse_angle(context, input))
+                let angle = input.try(|input| Self::parse_angle(context, input))
                     .unwrap_or_else(|_| Self::default_angle());
 
                 generics::FontStyle::Oblique(angle)
             }
         })
     }
 }
 
@@ -476,18 +476,17 @@ impl Parse for FontStretch {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // From https://drafts.csswg.org/css-fonts-4/#font-stretch-prop:
         //
         //    Values less than 0% are not allowed and are treated as parse
         //    errors.
-        if let Ok(percentage) = input.r#try(|input| Percentage::parse_non_negative(context, input))
-        {
+        if let Ok(percentage) = input.try(|input| Percentage::parse_non_negative(context, input)) {
             return Ok(FontStretch::Stretch(percentage));
         }
 
         Ok(FontStretch::Keyword(FontStretchKeyword::parse(input)?))
     }
 }
 
 impl ToComputedValue for FontStretch {
@@ -677,17 +676,17 @@ impl ToComputedValue for FontSizeAdjust 
 
 impl Parse for FontSizeAdjust {
     /// none | <number>
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontSizeAdjust, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(FontSizeAdjust::None);
         }
 
         Ok(FontSizeAdjust::Number(Number::parse_non_negative(
             context, input,
         )?))
@@ -985,22 +984,22 @@ impl FontSize {
 
     /// Parses a font-size, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<FontSize, ParseError<'i>> {
         if let Ok(lop) =
-            input.r#try(|i| LengthOrPercentage::parse_non_negative_quirky(context, i, allow_quirks))
+            input.try(|i| LengthOrPercentage::parse_non_negative_quirky(context, i, allow_quirks))
         {
             return Ok(FontSize::Length(lop));
         }
 
-        if let Ok(kw) = input.r#try(KeywordSize::parse) {
+        if let Ok(kw) = input.try(KeywordSize::parse) {
             return Ok(FontSize::Keyword(kw.into()));
         }
 
         try_match_ident_ignore_ascii_case! { input,
             "smaller" => Ok(FontSize::Smaller),
             "larger" => Ok(FontSize::Larger),
         }
     }
@@ -1172,34 +1171,34 @@ impl Parse for FontVariantAlternates {
     ///    ornaments(<feature-value-name>)           ||
     ///    annotation(<feature-value-name>) ]
     fn parse<'i, 't>(
         _: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontVariantAlternates, ParseError<'i>> {
         let mut alternates = Vec::new();
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(FontVariantAlternates::Value(VariantAlternatesList(
                 alternates.into_boxed_slice(),
             )));
         }
 
         let mut parsed_alternates = VariantAlternatesParsingFlags::empty();
         macro_rules! check_if_parsed(
             ($input:expr, $flag:path) => (
                 if parsed_alternates.contains($flag) {
                     return Err($input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
                 }
                 parsed_alternates |= $flag;
             )
         );
-        while let Ok(_) = input.r#try(|input| {
+        while let Ok(_) = input.try(|input| {
             // FIXME: remove clone() when lifetimes are non-lexical
             match input.next()?.clone() {
                 Token::Ident(ref value) if value.eq_ignore_ascii_case("historical-forms") => {
                     check_if_parsed!(input, VariantAlternatesParsingFlags::HISTORICAL_FORMS);
                     alternates.push(VariantAlternates::HistoricalForms);
                     Ok(())
                 },
                 Token::Function(ref name) => input.parse_nested_block(|i| {
@@ -1404,23 +1403,23 @@ impl Parse for FontVariantEastAsian {
     /// <east-asian-width-values>   = [ full-width | proportional-width ]
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontVariantEastAsian, ParseError<'i>> {
         let mut result = VariantEastAsian::empty();
 
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(FontVariantEastAsian::Value(result));
         }
 
-        while let Ok(flag) = input.r#try(|input| {
+        while let Ok(flag) = input.try(|input| {
             Ok(
                 match_ignore_ascii_case! { &input.expect_ident().map_err(|_| ())?,
                     "jis78" =>
                         exclusive_value!((result, VariantEastAsian::JIS78 | VariantEastAsian::JIS83 |
                                                   VariantEastAsian::JIS90 | VariantEastAsian::JIS04 |
                                                   VariantEastAsian::SIMPLIFIED | VariantEastAsian::TRADITIONAL
                                         ) => VariantEastAsian::JIS78),
                     "jis83" =>
@@ -1628,29 +1627,29 @@ impl Parse for FontVariantLigatures {
     /// <contextual-alt-values>    = [ contextual | no-contextual ]
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontVariantLigatures, ParseError<'i>> {
         let mut result = VariantLigatures::empty();
 
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(FontVariantLigatures::Value(result));
         }
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(FontVariantLigatures::Value(VariantLigatures::NONE));
         }
 
-        while let Ok(flag) = input.r#try(|input| {
+        while let Ok(flag) = input.try(|input| {
             Ok(
                 match_ignore_ascii_case! { &input.expect_ident().map_err(|_| ())?,
                     "common-ligatures" =>
                         exclusive_value!((result, VariantLigatures::COMMON_LIGATURES |
                                                   VariantLigatures::NO_COMMON_LIGATURES
                                         ) => VariantLigatures::COMMON_LIGATURES),
                     "no-common-ligatures" =>
                         exclusive_value!((result, VariantLigatures::COMMON_LIGATURES |
@@ -1837,23 +1836,23 @@ impl Parse for FontVariantNumeric {
     /// <numeric-fraction-values> = [ diagonal-fractions | stacked-fractions ]
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontVariantNumeric, ParseError<'i>> {
         let mut result = VariantNumeric::empty();
 
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(FontVariantNumeric::Value(result));
         }
 
-        while let Ok(flag) = input.r#try(|input| {
+        while let Ok(flag) = input.try(|input| {
             Ok(
                 match_ignore_ascii_case! { &input.expect_ident().map_err(|_| ())?,
                     "ordinal" =>
                         exclusive_value!((result, VariantNumeric::ORDINAL) => VariantNumeric::ORDINAL),
                     "slashed-zero" =>
                         exclusive_value!((result, VariantNumeric::SLASHED_ZERO) => VariantNumeric::SLASHED_ZERO),
                     "lining-nums" =>
                         exclusive_value!((result, VariantNumeric::LINING_NUMS |
@@ -1977,24 +1976,24 @@ impl Parse for FontSynthesis {
         let mut result = FontSynthesis {
             weight: false,
             style: false,
         };
         try_match_ident_ignore_ascii_case! { input,
             "none" => Ok(result),
             "weight" => {
                 result.weight = true;
-                if input.r#try(|input| input.expect_ident_matching("style")).is_ok() {
+                if input.try(|input| input.expect_ident_matching("style")).is_ok() {
                     result.style = true;
                 }
                 Ok(result)
             },
             "style" => {
                 result.style = true;
-                if input.r#try(|input| input.expect_ident_matching("weight")).is_ok() {
+                if input.try(|input| input.expect_ident_matching("weight")).is_ok() {
                     result.weight = true;
                 }
                 Ok(result)
             },
         }
     }
 }
 
@@ -2123,17 +2122,17 @@ impl ToComputedValue for FontLanguageOve
 
 impl Parse for FontLanguageOverride {
     /// normal | <string>
     fn parse<'i, 't>(
         _: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<FontLanguageOverride, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("normal"))
+            .try(|input| input.expect_ident_matching("normal"))
             .is_ok()
         {
             return Ok(FontLanguageOverride::Normal);
         }
 
         let string = input.expect_string()?;
         Ok(FontLanguageOverride::Override(
             string.as_ref().to_owned().into_boxed_str(),
@@ -2190,17 +2189,17 @@ impl Parse for FontVariationSettings {
         SpecifiedFontVariationSettings::parse(context, input).map(FontVariationSettings::Value)
     }
 }
 
 fn parse_one_feature_value<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
 ) -> Result<Integer, ParseError<'i>> {
-    if let Ok(integer) = input.r#try(|i| Integer::parse_non_negative(context, i)) {
+    if let Ok(integer) = input.try(|i| Integer::parse_non_negative(context, i)) {
         return Ok(integer);
     }
 
     try_match_ident_ignore_ascii_case! { input,
         "on" => Ok(Integer::new(1)),
         "off" => Ok(Integer::new(0)),
     }
 }
@@ -2208,17 +2207,17 @@ fn parse_one_feature_value<'i, 't>(
 impl Parse for FeatureTagValue<Integer> {
     /// https://drafts.csswg.org/css-fonts-4/#feature-tag-value
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let tag = FontTag::parse(context, input)?;
         let value = input
-            .r#try(|i| parse_one_feature_value(context, i))
+            .try(|i| parse_one_feature_value(context, i))
             .unwrap_or_else(|_| Integer::new(1));
 
         Ok(Self { tag, value })
     }
 }
 
 impl Parse for VariationValue<Number> {
     /// This is the `<string> <number>` part of the font-variation-settings
@@ -2326,17 +2325,17 @@ pub enum MozScriptLevel {
 }
 
 impl Parse for MozScriptLevel {
     fn parse<'i, 't>(
         _: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<MozScriptLevel, ParseError<'i>> {
         // We don't bother to handle calc here.
-        if let Ok(i) = input.r#try(|i| i.expect_integer()) {
+        if let Ok(i) = input.try(|i| i.expect_integer()) {
             return Ok(MozScriptLevel::Relative(i));
         }
         input.expect_ident_matching("auto")?;
         Ok(MozScriptLevel::Auto)
     }
 }
 
 #[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
--- a/servo/components/style/values/specified/gecko.rs
+++ b/servo/components/style/values/specified/gecko.rs
@@ -20,17 +20,17 @@ use style_traits::{CssWriter, ParseError
 /// A specified type for scroll snap points.
 pub type ScrollSnapPoint = GenericScrollSnapPoint<LengthOrPercentage>;
 
 impl Parse for ScrollSnapPoint {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(GenericScrollSnapPoint::None);
         }
         input.expect_function_matching("repeat")?;
         let length =
             input.parse_nested_block(|i| LengthOrPercentage::parse_non_negative(context, i))?;
         Ok(GenericScrollSnapPoint::Repeat(length))
     }
 }
--- a/servo/components/style/values/specified/grid.rs
+++ b/servo/components/style/values/specified/grid.rs
@@ -31,44 +31,41 @@ pub fn parse_flex<'i, 't>(input: &mut Pa
     }
 }
 
 impl Parse for TrackBreadth<LengthOrPercentage> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(lop) = input.r#try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
+        if let Ok(lop) = input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
             return Ok(TrackBreadth::Breadth(lop));
         }
 
-        if let Ok(f) = input.r#try(parse_flex) {
+        if let Ok(f) = input.try(parse_flex) {
             return Ok(TrackBreadth::Fr(f));
         }
 
         TrackKeyword::parse(input).map(TrackBreadth::Keyword)
     }
 }
 
 impl Parse for TrackSize<LengthOrPercentage> {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(b) = input.r#try(|i| TrackBreadth::parse(context, i)) {
+        if let Ok(b) = input.try(|i| TrackBreadth::parse(context, i)) {
             return Ok(TrackSize::Breadth(b));
         }
 
-        if input
-            .r#try(|i| i.expect_function_matching("minmax"))
-            .is_ok()
-        {
+        if input.try(|i| i.expect_function_matching("minmax")).is_ok() {
             return input.parse_nested_block(|input| {
                 let inflexible_breadth =
-                    match input.r#try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
+                    match input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
                         Ok(lop) => TrackBreadth::Breadth(lop),
                         Err(..) => {
                             let keyword = TrackKeyword::parse(input)?;
                             TrackBreadth::Keyword(keyword)
                         },
                     };
 
                 input.expect_comma()?;
@@ -90,17 +87,17 @@ impl Parse for TrackSize<LengthOrPercent
 ///
 /// <https://drafts.csswg.org/css-grid/#typedef-line-names>
 pub fn parse_line_names<'i, 't>(
     input: &mut Parser<'i, 't>,
 ) -> Result<Box<[CustomIdent]>, ParseError<'i>> {
     input.expect_square_bracket_block()?;
     input.parse_nested_block(|input| {
         let mut values = vec![];
-        while let Ok((loc, ident)) = input.r#try(|i| -> Result<_, CssParseError<()>> {
+        while let Ok((loc, ident)) = input.try(|i| -> Result<_, CssParseError<()>> {
             Ok((i.current_source_location(), i.expect_ident_cloned()?))
         }) {
             let ident = CustomIdent::from_ident(loc, &ident, &["span", "auto"])?;
             values.push(ident);
         }
 
         Ok(values.into_boxed_slice())
     })
@@ -121,17 +118,17 @@ enum RepeatType {
 }
 
 impl TrackRepeat<LengthOrPercentage, Integer> {
     fn parse_with_repeat_type<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<(Self, RepeatType), ParseError<'i>> {
         input
-            .r#try(|i| i.expect_function_matching("repeat").map_err(|e| e.into()))
+            .try(|i| i.expect_function_matching("repeat").map_err(|e| e.into()))
             .and_then(|_| {
                 input.parse_nested_block(|input| {
                     let count = RepeatCount::parse(context, input)?;
                     input.expect_comma()?;
 
                     let is_auto = count == RepeatCount::AutoFit || count == RepeatCount::AutoFill;
                     let mut repeat_type = if is_auto {
                         RepeatType::Auto
@@ -141,19 +138,19 @@ impl TrackRepeat<LengthOrPercentage, Int
                     };
 
                     let mut names = vec![];
                     let mut values = vec![];
                     let mut current_names;
 
                     loop {
                         current_names = input
-                            .r#try(parse_line_names)
+                            .try(parse_line_names)
                             .unwrap_or(vec![].into_boxed_slice());
-                        if let Ok(track_size) = input.r#try(|i| TrackSize::parse(context, i)) {
+                        if let Ok(track_size) = input.try(|i| TrackSize::parse(context, i)) {
                             if !track_size.is_fixed() {
                                 if is_auto {
                                     // should be <fixed-size> for <auto-repeat>
                                     return Err(input
                                         .new_custom_error(StyleParseErrorKind::UnspecifiedError));
                                 }
 
                                 if repeat_type == RepeatType::Fixed {
@@ -167,17 +164,17 @@ impl TrackRepeat<LengthOrPercentage, Int
                                 // FIXME: In the older version of the spec
                                 // (https://www.w3.org/TR/2015/WD-css-grid-1-20150917/#typedef-auto-repeat),
                                 // if the repeat type is `<auto-repeat>` we shouldn't try to parse more than
                                 // one `TrackSize`. But in current version of the spec, this is deprecated
                                 // but we are adding this for gecko parity. We should remove this when
                                 // gecko implements new spec.
                                 names.push(
                                     input
-                                        .r#try(parse_line_names)
+                                        .try(parse_line_names)
                                         .unwrap_or(vec![].into_boxed_slice()),
                                 );
                                 break;
                             }
                         } else {
                             if values.is_empty() {
                                 // expecting at least one <track-size>
                                 return Err(
@@ -221,33 +218,33 @@ impl Parse for TrackList<LengthOrPercent
         // account to set the position of <auto-repeat> so it remains the same while computing
         // values.
         let mut auto_offset = 0;
         // assume that everything is <fixed-size>. This flag is useful when we encounter <auto-repeat>
         let mut atleast_one_not_fixed = false;
         loop {
             current_names.extend_from_slice(
                 &mut input
-                    .r#try(parse_line_names)
+                    .try(parse_line_names)
                     .unwrap_or(vec![].into_boxed_slice()),
             );
-            if let Ok(track_size) = input.r#try(|i| TrackSize::parse(context, i)) {
+            if let Ok(track_size) = input.try(|i| TrackSize::parse(context, i)) {
                 if !track_size.is_fixed() {
                     atleast_one_not_fixed = true;
                     if auto_repeat.is_some() {
                         // <auto-track-list> only accepts <fixed-size> and <fixed-repeat>
                         return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                     }
                 }
 
                 let vec = mem::replace(&mut current_names, vec![]);
                 names.push(vec.into_boxed_slice());
                 values.push(TrackListValue::TrackSize(track_size));
             } else if let Ok((repeat, type_)) =
-                input.r#try(|i| TrackRepeat::parse_with_repeat_type(context, i))
+                input.try(|i| TrackRepeat::parse_with_repeat_type(context, i))
             {
                 if list_type == TrackListType::Explicit {
                     list_type = TrackListType::Normal; // <explicit-track-list> doesn't contain repeat()
                 }
 
                 match type_ {
                     RepeatType::Normal => {
                         atleast_one_not_fixed = true;
@@ -399,31 +396,31 @@ fn allow_grid_template_subgrids() -> boo
 }
 
 impl Parse for GridTemplateComponent<LengthOrPercentage, Integer> {
     // FIXME: Derive Parse (probably with None_)
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(GridTemplateComponent::None);
         }
 
         Self::parse_without_none(context, input)
     }
 }
 
 impl GridTemplateComponent<LengthOrPercentage, Integer> {
     /// Parses a `GridTemplateComponent<LengthOrPercentage>` except `none` keyword.
     pub fn parse_without_none<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if allow_grid_template_subgrids() {
-            if let Ok(t) = input.r#try(|i| LineNameList::parse(context, i)) {
+            if let Ok(t) = input.try(|i| LineNameList::parse(context, i)) {
                 return Ok(GridTemplateComponent::Subgrid(t));
             }
         }
 
         TrackList::parse(context, input).map(GridTemplateComponent::TrackList)
     }
 }
--- a/servo/components/style/values/specified/image.rs
+++ b/servo/components/style/values/specified/image.rs
@@ -34,17 +34,17 @@ pub type ImageLayer = Either<None_, Imag
 
 impl ImageLayer {
     /// This is a specialization of Either with an alternative parse
     /// method to provide anonymous CORS headers for the Image url fetch.
     pub fn parse_with_cors_anonymous<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(v) = input.r#try(|i| None_::parse(context, i)) {
+        if let Ok(v) = input.try(|i| None_::parse(context, i)) {
             return Ok(Either::First(v));
         }
         Image::parse_with_cors_anonymous(context, input).map(Either::Second)
     }
 }
 
 /// Specified values for an image according to CSS-IMAGES.
 /// <https://drafts.csswg.org/css-images/#image-values>
@@ -137,29 +137,29 @@ pub type ColorStop = generic::ColorStop<
 /// -moz-image-rect(<uri>, top, right, bottom, left);
 pub type MozImageRect = generic::MozImageRect<NumberOrPercentage, SpecifiedImageUrl>;
 
 impl Parse for Image {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Image, ParseError<'i>> {
-        if let Ok(url) = input.r#try(|input| SpecifiedImageUrl::parse(context, input)) {
+        if let Ok(url) = input.try(|input| SpecifiedImageUrl::parse(context, input)) {
             return Ok(generic::Image::Url(url));
         }
-        if let Ok(gradient) = input.r#try(|i| Gradient::parse(context, i)) {
+        if let Ok(gradient) = input.try(|i| Gradient::parse(context, i)) {
             return Ok(generic::Image::Gradient(Box::new(gradient)));
         }
         #[cfg(feature = "servo")]
         {
-            if let Ok(paint_worklet) = input.r#try(|i| PaintWorklet::parse(context, i)) {
+            if let Ok(paint_worklet) = input.try(|i| PaintWorklet::parse(context, i)) {
                 return Ok(generic::Image::PaintWorklet(paint_worklet));
             }
         }
-        if let Ok(image_rect) = input.r#try(|input| MozImageRect::parse(context, input)) {
+        if let Ok(image_rect) = input.try(|input| MozImageRect::parse(context, input)) {
             return Ok(generic::Image::Rect(Box::new(image_rect)));
         }
         Ok(generic::Image::Element(Image::parse_element(input)?))
     }
 }
 
 impl Image {
     /// Creates an already specified image value from an already resolved URL
@@ -167,17 +167,17 @@ impl Image {
     #[cfg(feature = "servo")]
     pub fn for_cascade(url: ServoUrl) -> Self {
         use crate::values::CssUrl;
         generic::Image::Url(CssUrl::for_cascade(url))
     }
 
     /// Parses a `-moz-element(# <element-id>)`.
     fn parse_element<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Atom, ParseError<'i>> {
-        input.r#try(|i| i.expect_function_matching("-moz-element"))?;
+        input.try(|i| i.expect_function_matching("-moz-element"))?;
         let location = input.current_source_location();
         input.parse_nested_block(|i| match *i.next()? {
             Token::IDHash(ref id) => Ok(Atom::from(id.as_ref())),
             ref t => Err(location.new_unexpected_token_error(t.clone())),
         })
     }
 
     /// Provides an alternate method for parsing that associates the URL with
@@ -185,17 +185,17 @@ impl Image {
     ///
     /// FIXME(emilio): It'd be nicer for this to pass a `CorsMode` parameter to
     /// a shared function instead.
     pub fn parse_with_cors_anonymous<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Image, ParseError<'i>> {
         if let Ok(url) =
-            input.r#try(|input| SpecifiedImageUrl::parse_with_cors_anonymous(context, input))
+            input.try(|input| SpecifiedImageUrl::parse_with_cors_anonymous(context, input))
         {
             return Ok(generic::Image::Url(url));
         }
         Self::parse(context, input)
     }
 }
 
 impl Parse for Gradient {
@@ -345,17 +345,17 @@ impl Gradient {
             }
         }
 
         impl Parse for Point {
             fn parse<'i, 't>(
                 context: &ParserContext,
                 input: &mut Parser<'i, 't>,
             ) -> Result<Self, ParseError<'i>> {
-                input.r#try(|i| {
+                input.try(|i| {
                     let x = Component::parse(context, i)?;
                     let y = Component::parse(context, i)?;
 
                     Ok(Self::new(x, y))
                 })
             }
         }
 
@@ -408,23 +408,23 @@ impl Gradient {
             }
         }
 
         impl<S: Parse> Parse for Component<S> {
             fn parse<'i, 't>(
                 context: &ParserContext,
                 input: &mut Parser<'i, 't>,
             ) -> Result<Self, ParseError<'i>> {
-                if let Ok(side) = input.r#try(|i| S::parse(context, i)) {
+                if let Ok(side) = input.try(|i| S::parse(context, i)) {
                     return Ok(Component::Side(side));
                 }
-                if let Ok(number) = input.r#try(|i| NumberOrPercentage::parse(context, i)) {
+                if let Ok(number) = input.try(|i| NumberOrPercentage::parse(context, i)) {
                     return Ok(Component::Number(number));
                 }
-                input.r#try(|i| i.expect_ident_matching("center"))?;
+                input.try(|i| i.expect_ident_matching("center"))?;
                 Ok(Component::Center)
             }
         }
 
         let ident = input.expect_ident_cloned()?;
         input.expect_comma()?;
 
         let (kind, reverse_stops) = match_ignore_ascii_case! { &ident,
@@ -472,17 +472,17 @@ impl Gradient {
             },
             _ => {
                 let e = SelectorParseErrorKind::UnexpectedIdent(ident.clone());
                 return Err(input.new_custom_error(e));
             },
         };
 
         let mut items = input
-            .r#try(|i| {
+            .try(|i| {
                 i.expect_comma()?;
                 i.parse_comma_separated(|i| {
                     let function = i.expect_function()?.clone();
                     let (color, mut p) = i.parse_nested_block(|i| {
                         let p = match_ignore_ascii_case! { &function,
                             "color-stop" => {
                                 let p = match NumberOrPercentage::parse(context, i)? {
                                     NumberOrPercentage::Number(number) => Percentage::new(number.value),
@@ -567,46 +567,46 @@ impl Gradient {
 impl GradientKind {
     /// Parses a linear gradient.
     /// CompatMode can change during `-moz-` prefixed gradient parsing if it come across a `to` keyword.
     fn parse_linear<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         compat_mode: &mut CompatMode,
     ) -> Result<Self, ParseError<'i>> {
-        let direction =
-            if let Ok(d) = input.r#try(|i| LineDirection::parse(context, i, compat_mode)) {
-                input.expect_comma()?;
-                d
-            } else {
-                match *compat_mode {
-                    CompatMode::Modern => LineDirection::Vertical(Y::Bottom),
-                    _ => LineDirection::Vertical(Y::Top),
-                }
-            };
+        let direction = if let Ok(d) = input.try(|i| LineDirection::parse(context, i, compat_mode))
+        {
+            input.expect_comma()?;
+            d
+        } else {
+            match *compat_mode {
+                CompatMode::Modern => LineDirection::Vertical(Y::Bottom),
+                _ => LineDirection::Vertical(Y::Top),
+            }
+        };
         Ok(generic::GradientKind::Linear(direction))
     }
 
     fn parse_radial<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         compat_mode: &mut CompatMode,
     ) -> Result<Self, ParseError<'i>> {
         let (shape, position, angle, moz_position) = match *compat_mode {
             CompatMode::Modern => {
-                let shape = input.r#try(|i| EndingShape::parse(context, i, *compat_mode));
-                let position = input.r#try(|i| {
+                let shape = input.try(|i| EndingShape::parse(context, i, *compat_mode));
+                let position = input.try(|i| {
                     i.expect_ident_matching("at")?;
                     Position::parse(context, i)
                 });
                 (shape, position.ok(), None, None)
             },
             CompatMode::WebKit => {
-                let position = input.r#try(|i| Position::parse(context, i));
-                let shape = input.r#try(|i| {
+                let position = input.try(|i| Position::parse(context, i));
+                let shape = input.try(|i| {
                     if position.is_ok() {
                         i.expect_comma()?;
                     }
                     EndingShape::parse(context, i, *compat_mode)
                 });
                 (shape, position.ok(), None, None)
             },
             // The syntax of `-moz-` prefixed radial gradient is:
@@ -615,23 +615,23 @@ impl GradientKind {
             //     [ <position> || <angle> ]?  [ [ circle | ellipse ] | <extent-keyword> ] , |
             //   ]?
             //   <color-stop> [ , <color-stop> ]+
             // )
             // where <extent-keyword> = closest-corner | closest-side | farthest-corner | farthest-side |
             //                          cover | contain
             // and <color-stop>     = <color> [ <percentage> | <length> ]?
             CompatMode::Moz => {
-                let mut position = input.r#try(|i| LegacyPosition::parse(context, i));
-                let angle = input.r#try(|i| Angle::parse(context, i)).ok();
+                let mut position = input.try(|i| LegacyPosition::parse(context, i));
+                let angle = input.try(|i| Angle::parse(context, i)).ok();
                 if position.is_err() {
-                    position = input.r#try(|i| LegacyPosition::parse(context, i));
+                    position = input.try(|i| LegacyPosition::parse(context, i));
                 }
 
-                let shape = input.r#try(|i| {
+                let shape = input.try(|i| {
                     if position.is_ok() || angle.is_some() {
                         i.expect_comma()?;
                     }
                     EndingShape::parse(context, i, *compat_mode)
                 });
 
                 (shape, None, angle, position.ok())
             },
@@ -763,28 +763,28 @@ impl generic::LineDirection for LineDire
 
 impl LineDirection {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         compat_mode: &mut CompatMode,
     ) -> Result<Self, ParseError<'i>> {
         let mut _angle = if *compat_mode == CompatMode::Moz {
-            input.r#try(|i| Angle::parse(context, i)).ok()
+            input.try(|i| Angle::parse(context, i)).ok()
         } else {
             // Gradients allow unitless zero angles as an exception, see:
             // https://github.com/w3c/csswg-drafts/issues/1162
-            if let Ok(angle) = input.r#try(|i| Angle::parse_with_unitless(context, i)) {
+            if let Ok(angle) = input.try(|i| Angle::parse_with_unitless(context, i)) {
                 return Ok(LineDirection::Angle(angle));
             }
             None
         };
 
-        input.r#try(|i| {
-            let to_ident = i.r#try(|i| i.expect_ident_matching("to"));
+        input.try(|i| {
+            let to_ident = i.try(|i| i.expect_ident_matching("to"));
             match *compat_mode {
                 // `to` keyword is mandatory in modern syntax.
                 CompatMode::Modern => to_ident?,
                 // Fall back to Modern compatibility mode in case there is a `to` keyword.
                 // According to Gecko, `-moz-linear-gradient(to ...)` should serialize like
                 // `linear-gradient(to ...)`.
                 CompatMode::Moz if to_ident.is_ok() => *compat_mode = CompatMode::Modern,
                 // There is no `to` keyword in webkit prefixed syntax. If it's consumed,
@@ -796,36 +796,36 @@ impl LineDirection {
                 },
                 _ => {},
             }
 
             #[cfg(feature = "gecko")]
             {
                 // `-moz-` prefixed linear gradient can be both Angle and Position.
                 if *compat_mode == CompatMode::Moz {
-                    let position = i.r#try(|i| LegacyPosition::parse(context, i)).ok();
+                    let position = i.try(|i| LegacyPosition::parse(context, i)).ok();
                     if _angle.is_none() {
-                        _angle = i.r#try(|i| Angle::parse(context, i)).ok();
+                        _angle = i.try(|i| Angle::parse(context, i)).ok();
                     };
 
                     if _angle.is_none() && position.is_none() {
                         return Err(i.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                     }
                     return Ok(LineDirection::MozPosition(position, _angle));
                 }
             }
 
-            if let Ok(x) = i.r#try(X::parse) {
-                if let Ok(y) = i.r#try(Y::parse) {
+            if let Ok(x) = i.try(X::parse) {
+                if let Ok(y) = i.try(Y::parse) {
                     return Ok(LineDirection::Corner(x, y));
                 }
                 return Ok(LineDirection::Horizontal(x));
             }
             let y = Y::parse(i)?;
-            if let Ok(x) = i.r#try(X::parse) {
+            if let Ok(x) = i.try(X::parse) {
                 return Ok(LineDirection::Corner(x, y));
             }
             Ok(LineDirection::Vertical(y))
         })
     }
 }
 
 #[cfg(feature = "gecko")]
@@ -845,91 +845,89 @@ impl ToComputedValue for GradientPositio
 }
 
 impl EndingShape {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         compat_mode: CompatMode,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(extent) = input.r#try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode)) {
-            if input.r#try(|i| i.expect_ident_matching("circle")).is_ok() {
+        if let Ok(extent) = input.try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode)) {
+            if input.try(|i| i.expect_ident_matching("circle")).is_ok() {
                 return Ok(generic::EndingShape::Circle(Circle::Extent(extent)));
             }
-            let _ = input.r#try(|i| i.expect_ident_matching("ellipse"));
+            let _ = input.try(|i| i.expect_ident_matching("ellipse"));
             return Ok(generic::EndingShape::Ellipse(Ellipse::Extent(extent)));
         }
-        if input.r#try(|i| i.expect_ident_matching("circle")).is_ok() {
-            if let Ok(extent) = input.r#try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode))
-            {
+        if input.try(|i| i.expect_ident_matching("circle")).is_ok() {
+            if let Ok(extent) = input.try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode)) {
                 return Ok(generic::EndingShape::Circle(Circle::Extent(extent)));
             }
             if compat_mode == CompatMode::Modern {
-                if let Ok(length) = input.r#try(|i| Length::parse(context, i)) {
+                if let Ok(length) = input.try(|i| Length::parse(context, i)) {
                     return Ok(generic::EndingShape::Circle(Circle::Radius(length)));
                 }
             }
             return Ok(generic::EndingShape::Circle(Circle::Extent(
                 ShapeExtent::FarthestCorner,
             )));
         }
-        if input.r#try(|i| i.expect_ident_matching("ellipse")).is_ok() {
-            if let Ok(extent) = input.r#try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode))
-            {
+        if input.try(|i| i.expect_ident_matching("ellipse")).is_ok() {
+            if let Ok(extent) = input.try(|i| ShapeExtent::parse_with_compat_mode(i, compat_mode)) {
                 return Ok(generic::EndingShape::Ellipse(Ellipse::Extent(extent)));
             }
             if compat_mode == CompatMode::Modern {
-                let pair: Result<_, ParseError> = input.r#try(|i| {
+                let pair: Result<_, ParseError> = input.try(|i| {
                     let x = LengthOrPercentage::parse(context, i)?;
                     let y = LengthOrPercentage::parse(context, i)?;
                     Ok((x, y))
                 });
                 if let Ok((x, y)) = pair {
                     return Ok(generic::EndingShape::Ellipse(Ellipse::Radii(x, y)));
                 }
             }
             return Ok(generic::EndingShape::Ellipse(Ellipse::Extent(
                 ShapeExtent::FarthestCorner,
             )));
         }
         // -moz- prefixed radial gradient doesn't allow EndingShape's Length or LengthOrPercentage
         // to come before shape keyword. Otherwise it conflicts with <position>.
         if compat_mode != CompatMode::Moz {
-            if let Ok(length) = input.r#try(|i| Length::parse(context, i)) {
-                if let Ok(y) = input.r#try(|i| LengthOrPercentage::parse(context, i)) {
+            if let Ok(length) = input.try(|i| Length::parse(context, i)) {
+                if let Ok(y) = input.try(|i| LengthOrPercentage::parse(context, i)) {
                     if compat_mode == CompatMode::Modern {
-                        let _ = input.r#try(|i| i.expect_ident_matching("ellipse"));
+                        let _ = input.try(|i| i.expect_ident_matching("ellipse"));
                     }
                     return Ok(generic::EndingShape::Ellipse(Ellipse::Radii(
                         length.into(),
                         y,
                     )));
                 }
                 if compat_mode == CompatMode::Modern {
-                    let y = input.r#try(|i| {
+                    let y = input.try(|i| {
                         i.expect_ident_matching("ellipse")?;
                         LengthOrPercentage::parse(context, i)
                     });
                     if let Ok(y) = y {
                         return Ok(generic::EndingShape::Ellipse(Ellipse::Radii(
                             length.into(),
                             y,
                         )));
                     }
-                    let _ = input.r#try(|i| i.expect_ident_matching("circle"));
+                    let _ = input.try(|i| i.expect_ident_matching("circle"));
                 }
 
                 return Ok(generic::EndingShape::Circle(Circle::Radius(length)));
             }
         }
-        input.r#try(|i| {
+        input.try(|i| {
             let x = Percentage::parse(context, i)?;
-            let y = if let Ok(y) = i.r#try(|i| LengthOrPercentage::parse(context, i)) {
+            let y = if let Ok(y) = i.try(|i| LengthOrPercentage::parse(context, i)) {
                 if compat_mode == CompatMode::Modern {
-                    let _ = i.r#try(|i| i.expect_ident_matching("ellipse"));
+                    let _ = i.try(|i| i.expect_ident_matching("ellipse"));
                 }
                 y
             } else {
                 if compat_mode == CompatMode::Modern {
                     i.expect_ident_matching("ellipse")?;
                 }
                 LengthOrPercentage::parse(context, i)?
             };
@@ -960,26 +958,26 @@ impl GradientItem {
         input: &mut Parser<'i, 't>,
     ) -> Result<Vec<Self>, ParseError<'i>> {
         let mut items = Vec::new();
         let mut seen_stop = false;
 
         loop {
             input.parse_until_before(Delimiter::Comma, |input| {
                 if seen_stop {
-                    if let Ok(hint) = input.r#try(|i| LengthOrPercentage::parse(context, i)) {
+                    if let Ok(hint) = input.try(|i| LengthOrPercentage::parse(context, i)) {
                         seen_stop = false;
                         items.push(generic::GradientItem::InterpolationHint(hint));
                         return Ok(());
                     }
                 }
 
                 let stop = ColorStop::parse(context, input)?;
 
-                if let Ok(multi_position) = input.r#try(|i| LengthOrPercentage::parse(context, i)) {
+                if let Ok(multi_position) = input.try(|i| LengthOrPercentage::parse(context, i)) {
                     let stop_color = stop.color.clone();
                     items.push(generic::GradientItem::ColorStop(stop));
                     items.push(generic::GradientItem::ColorStop(ColorStop {
                         color: stop_color,
                         position: Some(multi_position),
                     }));
                 } else {
                     items.push(generic::GradientItem::ColorStop(stop));
@@ -1005,46 +1003,46 @@ impl GradientItem {
 
 impl Parse for ColorStop {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         Ok(ColorStop {
             color: Color::parse(context, input)?,
-            position: input.r#try(|i| LengthOrPercentage::parse(context, i)).ok(),
+            position: input.try(|i| LengthOrPercentage::parse(context, i)).ok(),
         })
     }
 }
 
 impl Parse for PaintWorklet {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         input.expect_function_matching("paint")?;
         input.parse_nested_block(|input| {
             let name = Atom::from(&**input.expect_ident()?);
             let arguments = input
-                .r#try(|input| {
+                .try(|input| {
                     input.expect_comma()?;
                     input.parse_comma_separated(|input| SpecifiedValue::parse(input))
                 })
                 .unwrap_or(vec![]);
             Ok(PaintWorklet { name, arguments })
         })
     }
 }
 
 impl Parse for MozImageRect {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        input.r#try(|i| i.expect_function_matching("-moz-image-rect"))?;
+        input.try(|i| i.expect_function_matching("-moz-image-rect"))?;
         input.parse_nested_block(|i| {
             let string = i.expect_url_or_string()?;
             let url = SpecifiedImageUrl::parse_from_string(string.as_ref().to_owned(), context);
             i.expect_comma()?;
             let top = NumberOrPercentage::parse_non_negative(context, i)?;
             i.expect_comma()?;
             let right = NumberOrPercentage::parse_non_negative(context, i)?;
             i.expect_comma()?;
--- a/servo/components/style/values/specified/length.rs
+++ b/servo/components/style/values/specified/length.rs
@@ -1223,17 +1223,17 @@ impl LengthOrNumber {
     /// Parse a non-negative LengthOrNumber.
     pub fn parse_non_negative<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // We try to parse as a Number first because, for cases like
         // LengthOrNumber, we want "0" to be parsed as a plain Number rather
         // than a Length (0px); this matches the behaviour of all major browsers
-        if let Ok(v) = input.r#try(|i| Number::parse_non_negative(context, i)) {
+        if let Ok(v) = input.try(|i| Number::parse_non_negative(context, i)) {
             return Ok(Either::Second(v));
         }
 
         Length::parse_non_negative(context, input).map(Either::First)
     }
 
     /// Returns `0`.
     #[inline]
@@ -1267,17 +1267,17 @@ impl MozLength {
     }
 
     /// Parses, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(l) = input.r#try(ExtremumLength::parse) {
+        if let Ok(l) = input.try(ExtremumLength::parse) {
             return Ok(GenericMozLength::ExtremumLength(l));
         }
 
         let length =
             LengthOrPercentageOrAuto::parse_non_negative_quirky(context, input, allow_quirks)?;
         Ok(GenericMozLength::LengthOrPercentageOrAuto(length))
     }
 
@@ -1319,17 +1319,17 @@ impl MaxLength {
     }
 
     /// Parses, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(l) = input.r#try(ExtremumLength::parse) {
+        if let Ok(l) = input.try(ExtremumLength::parse) {
             return Ok(GenericMaxLength::ExtremumLength(l));
         }
 
         let length =
             LengthOrPercentageOrNone::parse_non_negative_quirky(context, input, allow_quirks)?;
         Ok(GenericMaxLength::LengthOrPercentageOrNone(length))
     }
 }
--- a/servo/components/style/values/specified/list.rs
+++ b/servo/components/style/values/specified/list.rs
@@ -58,17 +58,17 @@ impl ListStyleType {
 }
 
 #[cfg(feature = "gecko")]
 impl Parse for ListStyleType {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(style) = input.r#try(|i| CounterStyleOrNone::parse(context, i)) {
+        if let Ok(style) = input.try(|i| CounterStyleOrNone::parse(context, i)) {
             return Ok(ListStyleType::CounterStyle(style));
         }
 
         Ok(ListStyleType::String(
             input.expect_string()?.as_ref().to_owned(),
         ))
     }
 }
@@ -92,17 +92,17 @@ pub struct Quotes(
 );
 
 impl Parse for Quotes {
     fn parse<'i, 't>(
         _: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Quotes, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(Quotes(Arc::new(Box::new([]))));
         }
 
         let mut quotes = Vec::new();
         loop {
             let location = input.current_source_location();
--- a/servo/components/style/values/specified/mod.rs
+++ b/servo/components/style/values/specified/mod.rs
@@ -354,17 +354,17 @@ pub enum NumberOrPercentage {
 }
 
 impl NumberOrPercentage {
     fn parse_with_clamping_mode<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         type_: AllowedNumericType,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(per) = input.r#try(|i| Percentage::parse_with_clamping_mode(context, i, type_)) {
+        if let Ok(per) = input.try(|i| Percentage::parse_with_clamping_mode(context, i, type_)) {
             return Ok(NumberOrPercentage::Percentage(per));
         }
 
         parse_number_with_clamping_mode(context, input, type_).map(NumberOrPercentage::Number)
     }
 
     /// Parse a non-negative number or percentage.
     pub fn parse_non_negative<'i, 't>(
@@ -698,34 +698,34 @@ impl ClipRect {
         use crate::values::specified::Length;
 
         fn parse_argument<'i, 't>(
             context: &ParserContext,
             input: &mut Parser<'i, 't>,
             allow_quirks: AllowQuirks,
         ) -> Result<Option<Length>, ParseError<'i>> {
             if input
-                .r#try(|input| input.expect_ident_matching("auto"))
+                .try(|input| input.expect_ident_matching("auto"))
                 .is_ok()
             {
                 Ok(None)
             } else {
                 Length::parse_quirky(context, input, allow_quirks).map(Some)
             }
         }
 
         input.expect_function_matching("rect")?;
 
         input.parse_nested_block(|input| {
             let top = parse_argument(context, input, allow_quirks)?;
             let right;
             let bottom;
             let left;
 
-            if input.r#try(|input| input.expect_comma()).is_ok() {
+            if input.try(|input| input.expect_comma()).is_ok() {
                 right = parse_argument(context, input, allow_quirks)?;
                 input.expect_comma()?;
                 bottom = parse_argument(context, input, allow_quirks)?;
                 input.expect_comma()?;
                 left = parse_argument(context, input, allow_quirks)?;
             } else {
                 right = parse_argument(context, input, allow_quirks)?;
                 bottom = parse_argument(context, input, allow_quirks)?;
@@ -746,17 +746,17 @@ pub type ClipRectOrAuto = Either<ClipRec
 
 impl ClipRectOrAuto {
     /// Parses a ClipRect or Auto, allowing quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(v) = input.r#try(|i| ClipRect::parse_quirky(context, i, allow_quirks)) {
+        if let Ok(v) = input.try(|i| ClipRect::parse_quirky(context, i, allow_quirks)) {
             Ok(Either::First(v))
         } else {
             Auto::parse(context, input).map(Either::Second)
         }
     }
 }
 
 /// Whether quirks are allowed in this context.
@@ -811,18 +811,18 @@ impl Attr {
     /// Parse contents of attr() assuming we have already parsed `attr` and are
     /// within a parse_nested_block()
     pub fn parse_function<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Attr, ParseError<'i>> {
         // Syntax is `[namespace? `|`]? ident`
         // no spaces allowed
-        let first = input.r#try(|i| i.expect_ident_cloned()).ok();
-        if let Ok(token) = input.r#try(|i| i.next_including_whitespace().map(|t| t.clone())) {
+        let first = input.try(|i| i.expect_ident_cloned()).ok();
+        if let Ok(token) = input.try(|i| i.next_including_whitespace().map(|t| t.clone())) {
             match token {
                 Token::Delim('|') => {
                     let location = input.current_source_location();
                     // must be followed by an ident
                     let second_token = match *input.next_including_whitespace()? {
                         Token::Ident(ref second) => second,
                         ref t => return Err(location.new_unexpected_token_error(t.clone())),
                     };
--- a/servo/components/style/values/specified/motion.rs
+++ b/servo/components/style/values/specified/motion.rs
@@ -45,17 +45,17 @@ impl OffsetPath {
 }
 
 impl Parse for OffsetPath {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // Parse none.
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(OffsetPath::none());
         }
 
         // Parse possible functions.
         let location = input.current_source_location();
         let function = input.expect_function()?.clone();
         input.parse_nested_block(move |i| {
             match_ignore_ascii_case! { &function,
--- a/servo/components/style/values/specified/outline.rs
+++ b/servo/components/style/values/specified/outline.rs
@@ -48,17 +48,17 @@ impl OutlineStyle {
     }
 }
 
 impl Parse for OutlineStyle {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<OutlineStyle, ParseError<'i>> {
-        if let Ok(border_style) = input.r#try(BorderStyle::parse) {
+        if let Ok(border_style) = input.try(BorderStyle::parse) {
             if let BorderStyle::Hidden = border_style {
                 return Err(input
                     .new_custom_error(SelectorParseErrorKind::UnexpectedIdent("hidden".into())));
             }
 
             return Ok(OutlineStyle::Other(border_style));
         }
 
--- a/servo/components/style/values/specified/position.rs
+++ b/servo/components/style/values/specified/position.rs
@@ -97,72 +97,72 @@ impl Parse for Position {
 
 impl Position {
     /// Parses a `<position>`, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        match input.r#try(|i| PositionComponent::parse_quirky(context, i, allow_quirks)) {
+        match input.try(|i| PositionComponent::parse_quirky(context, i, allow_quirks)) {
             Ok(x_pos @ PositionComponent::Center) => {
                 if let Ok(y_pos) =
-                    input.r#try(|i| PositionComponent::parse_quirky(context, i, allow_quirks))
+                    input.try(|i| PositionComponent::parse_quirky(context, i, allow_quirks))
                 {
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 let x_pos = input
-                    .r#try(|i| PositionComponent::parse_quirky(context, i, allow_quirks))
+                    .try(|i| PositionComponent::parse_quirky(context, i, allow_quirks))
                     .unwrap_or(x_pos);
                 let y_pos = PositionComponent::Center;
                 return Ok(Self::new(x_pos, y_pos));
             },
             Ok(PositionComponent::Side(x_keyword, lop)) => {
-                if input.r#try(|i| i.expect_ident_matching("center")).is_ok() {
+                if input.try(|i| i.expect_ident_matching("center")).is_ok() {
                     let x_pos = PositionComponent::Side(x_keyword, lop);
                     let y_pos = PositionComponent::Center;
                     return Ok(Self::new(x_pos, y_pos));
                 }
-                if let Ok(y_keyword) = input.r#try(Y::parse) {
+                if let Ok(y_keyword) = input.try(Y::parse) {
                     let y_lop = input
-                        .r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                        .try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                         .ok();
                     let x_pos = PositionComponent::Side(x_keyword, lop);
                     let y_pos = PositionComponent::Side(y_keyword, y_lop);
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 let x_pos = PositionComponent::Side(x_keyword, None);
                 let y_pos = lop.map_or(PositionComponent::Center, PositionComponent::Length);
                 return Ok(Self::new(x_pos, y_pos));
             },
             Ok(x_pos @ PositionComponent::Length(_)) => {
-                if let Ok(y_keyword) = input.r#try(Y::parse) {
+                if let Ok(y_keyword) = input.try(Y::parse) {
                     let y_pos = PositionComponent::Side(y_keyword, None);
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 if let Ok(y_lop) =
-                    input.r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                    input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                 {
                     let y_pos = PositionComponent::Length(y_lop);
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 let y_pos = PositionComponent::Center;
-                let _ = input.r#try(|i| i.expect_ident_matching("center"));
+                let _ = input.try(|i| i.expect_ident_matching("center"));
                 return Ok(Self::new(x_pos, y_pos));
             },
             Err(_) => {},
         }
         let y_keyword = Y::parse(input)?;
-        let lop_and_x_pos: Result<_, ParseError> = input.r#try(|i| {
+        let lop_and_x_pos: Result<_, ParseError> = input.try(|i| {
             let y_lop = i
-                .r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                .try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                 .ok();
-            if let Ok(x_keyword) = i.r#try(X::parse) {
+            if let Ok(x_keyword) = i.try(X::parse) {
                 let x_lop = i
-                    .r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                    .try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                     .ok();
                 let x_pos = PositionComponent::Side(x_keyword, x_lop);
                 return Ok((y_lop, x_pos));
             };
             i.expect_ident_matching("center")?;
             let x_pos = PositionComponent::Center;
             Ok((y_lop, x_pos))
         });
@@ -225,26 +225,25 @@ impl<S: Parse> Parse for PositionCompone
 
 impl<S: Parse> PositionComponent<S> {
     /// Parses a component of a CSS position, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("center")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("center")).is_ok() {
             return Ok(PositionComponent::Center);
         }
-        if let Ok(lop) = input.r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
-        {
+        if let Ok(lop) = input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks)) {
             return Ok(PositionComponent::Length(lop));
         }
         let keyword = S::parse(context, input)?;
         let lop = input
-            .r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+            .try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
             .ok();
         Ok(PositionComponent::Side(keyword, lop))
     }
 }
 
 impl<S> PositionComponent<S> {
     /// `0%`
     pub fn zero() -> Self {
@@ -355,61 +354,61 @@ impl Parse for LegacyPosition {
 
 impl LegacyPosition {
     /// Parses a `<position>`, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        match input.r#try(|i| OriginComponent::parse(context, i)) {
+        match input.try(|i| OriginComponent::parse(context, i)) {
             Ok(x_pos @ OriginComponent::Center) => {
-                if let Ok(y_pos) = input.r#try(|i| OriginComponent::parse(context, i)) {
+                if let Ok(y_pos) = input.try(|i| OriginComponent::parse(context, i)) {
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 let x_pos = input
-                    .r#try(|i| OriginComponent::parse(context, i))
+                    .try(|i| OriginComponent::parse(context, i))
                     .unwrap_or(x_pos);
                 let y_pos = OriginComponent::Center;
                 return Ok(Self::new(x_pos, y_pos));
             },
             Ok(OriginComponent::Side(x_keyword)) => {
-                if let Ok(y_keyword) = input.r#try(Y::parse) {
+                if let Ok(y_keyword) = input.try(Y::parse) {
                     let x_pos = OriginComponent::Side(x_keyword);
                     let y_pos = OriginComponent::Side(y_keyword);
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 let x_pos = OriginComponent::Side(x_keyword);
                 if let Ok(y_lop) =
-                    input.r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                    input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                 {
                     return Ok(Self::new(x_pos, OriginComponent::Length(y_lop)));
                 }
-                let _ = input.r#try(|i| i.expect_ident_matching("center"));
+                let _ = input.try(|i| i.expect_ident_matching("center"));
                 return Ok(Self::new(x_pos, OriginComponent::Center));
             },
             Ok(x_pos @ OriginComponent::Length(_)) => {
-                if let Ok(y_keyword) = input.r#try(Y::parse) {
+                if let Ok(y_keyword) = input.try(Y::parse) {
                     let y_pos = OriginComponent::Side(y_keyword);
                     return Ok(Self::new(x_pos, y_pos));
                 }
                 if let Ok(y_lop) =
-                    input.r#try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
+                    input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
                 {
                     let y_pos = OriginComponent::Length(y_lop);
                     return Ok(Self::new(x_pos, y_pos));
                 }
-                let _ = input.r#try(|i| i.expect_ident_matching("center"));
+                let _ = input.try(|i| i.expect_ident_matching("center"));
                 return Ok(Self::new(x_pos, OriginComponent::Center));
             },
             Err(_) => {},
         }
         let y_keyword = Y::parse(input)?;
-        let x_pos: Result<_, ParseError> = input.r#try(|i| {
-            if let Ok(x_keyword) = i.r#try(X::parse) {
+        let x_pos: Result<_, ParseError> = input.try(|i| {
+            if let Ok(x_keyword) = i.try(X::parse) {
                 let x_pos = OriginComponent::Side(x_keyword);
                 return Ok(x_pos);
             }
             i.expect_ident_matching("center")?;
             Ok(OriginComponent::Center)
         });
         if let Ok(x_pos) = x_pos {
             let y_pos = OriginComponent::Side(y_keyword);
@@ -644,17 +643,17 @@ impl TemplateAreas {
 }
 
 impl Parse for TemplateAreas {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let mut strings = vec![];
-        while let Ok(string) = input.r#try(|i| i.expect_string().map(|s| s.as_ref().into())) {
+        while let Ok(string) = input.try(|i| i.expect_string().map(|s| s.as_ref().into())) {
             strings.push(string);
         }
 
         TemplateAreas::from_vec(strings)
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
 }
 
@@ -738,14 +737,14 @@ impl GridTemplateAreas {
 /// A specified value for the `z-index` property.
 pub type ZIndex = GenericZIndex<Integer>;
 
 impl Parse for ZIndex {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("auto")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
             return Ok(GenericZIndex::Auto);
         }
         Ok(GenericZIndex::Integer(Integer::parse(context, input)?))
     }
 }
--- a/servo/components/style/values/specified/source_size_list.rs
+++ b/servo/components/style/values/specified/source_size_list.rs
@@ -87,17 +87,17 @@ enum SourceSizeOrLength {
     Length(Length),
 }
 
 impl Parse for SourceSizeOrLength {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(size) = input.r#try(|input| SourceSize::parse(context, input)) {
+        if let Ok(size) = input.try(|input| SourceSize::parse(context, input)) {
             return Ok(SourceSizeOrLength::SourceSize(size));
         }
 
         let length = Length::parse_non_negative(context, input)?;
         Ok(SourceSizeOrLength::Length(length))
     }
 }
 
--- a/servo/components/style/values/specified/svg.rs
+++ b/servo/components/style/values/specified/svg.rs
@@ -58,17 +58,17 @@ pub type SvgLengthOrPercentageOrNumber =
 pub type SVGLength = generic::SVGLength<SvgLengthOrPercentageOrNumber>;
 
 impl Parse for SVGLength {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         input
-            .r#try(|i| SvgLengthOrPercentageOrNumber::parse(context, i))
+            .try(|i| SvgLengthOrPercentageOrNumber::parse(context, i))
             .map(Into::into)
             .or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
     }
 }
 
 impl From<SvgLengthOrPercentageOrNumber> for SVGLength {
     fn from(length: SvgLengthOrPercentageOrNumber) -> Self {
         generic::SVGLength::Length(length)
@@ -84,17 +84,17 @@ pub type NonNegativeSvgLengthOrPercentag
 pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthOrPercentageOrNumber>;
 
 impl Parse for SVGWidth {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         input
-            .r#try(|i| NonNegativeSvgLengthOrPercentageOrNumber::parse(context, i))
+            .try(|i| NonNegativeSvgLengthOrPercentageOrNumber::parse(context, i))
             .map(Into::into)
             .or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
     }
 }
 
 impl From<NonNegativeSvgLengthOrPercentageOrNumber> for SVGWidth {
     fn from(length: NonNegativeSvgLengthOrPercentageOrNumber) -> Self {
         generic::SVGLength::Length(length)
@@ -104,39 +104,39 @@ impl From<NonNegativeSvgLengthOrPercenta
 /// [ <length> | <percentage> | <number> ]# | context-value
 pub type SVGStrokeDashArray = generic::SVGStrokeDashArray<NonNegativeSvgLengthOrPercentageOrNumber>;
 
 impl Parse for SVGStrokeDashArray {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(values) = input.r#try(|i| {
+        if let Ok(values) = input.try(|i| {
             CommaWithSpace::parse(i, |i| {
                 NonNegativeSvgLengthOrPercentageOrNumber::parse(context, i)
             })
         }) {
             Ok(generic::SVGStrokeDashArray::Values(values))
-        } else if let Ok(_) = input.r#try(|i| i.expect_ident_matching("none")) {
+        } else if let Ok(_) = input.try(|i| i.expect_ident_matching("none")) {
             Ok(generic::SVGStrokeDashArray::Values(vec![]))
         } else {
             parse_context_value(input, generic::SVGStrokeDashArray::ContextValue)
         }
     }
 }
 
 /// <opacity-value> | context-fill-opacity | context-stroke-opacity
 pub type SVGOpacity = generic::SVGOpacity<Opacity>;
 
 impl Parse for SVGOpacity {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(opacity) = input.r#try(|i| Opacity::parse(context, i)) {
+        if let Ok(opacity) = input.try(|i| Opacity::parse(context, i)) {
             return Ok(generic::SVGOpacity::Opacity(opacity));
         }
 
         try_match_ident_ignore_ascii_case! { input,
             "context-fill-opacity" => Ok(generic::SVGOpacity::ContextFillOpacity),
             "context-stroke-opacity" => Ok(generic::SVGOpacity::ContextStrokeOpacity),
         }
     }
@@ -191,28 +191,28 @@ impl SVGPaintOrder {
     }
 }
 
 impl Parse for SVGPaintOrder {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<SVGPaintOrder, ParseError<'i>> {
-        if let Ok(()) = input.r#try(|i| i.expect_ident_matching("normal")) {
+        if let Ok(()) = input.try(|i| i.expect_ident_matching("normal")) {
             return Ok(SVGPaintOrder::normal());
         }
 
         let mut value = 0;
         // bitfield representing what we've seen so far
         // bit 1 is fill, bit 2 is stroke, bit 3 is markers
         let mut seen = 0;
         let mut pos = 0;
 
         loop {
-            let result: Result<_, ParseError> = input.r#try(|input| {
+            let result: Result<_, ParseError> = input.try(|input| {
                 try_match_ident_ignore_ascii_case! { input,
                     "fill" => Ok(PaintOrder::Fill),
                     "stroke" => Ok(PaintOrder::Stroke),
                     "markers" => Ok(PaintOrder::Markers),
                 }
             });
 
             match result {
--- a/servo/components/style/values/specified/text.rs
+++ b/servo/components/style/values/specified/text.rs
@@ -40,21 +40,21 @@ pub type WordSpacing = Spacing<LengthOrP
 /// A specified value for the `line-height` property.
 pub type LineHeight = GenericLineHeight<NonNegativeNumber, NonNegativeLengthOrPercentage>;
 
 impl Parse for InitialLetter {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("normal")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("normal")).is_ok() {
             return Ok(GenericInitialLetter::Normal);
         }
         let size = Number::parse_at_least_one(context, input)?;
-        let sink = input.r#try(|i| Integer::parse_positive(context, i)).ok();
+        let sink = input.try(|i| Integer::parse_positive(context, i)).ok();
         Ok(GenericInitialLetter::Specified(size, sink))
     }
 }
 
 impl Parse for LetterSpacing {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
@@ -76,20 +76,20 @@ impl Parse for WordSpacing {
     }
 }
 
 impl Parse for LineHeight {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(number) = input.r#try(|i| NonNegativeNumber::parse(context, i)) {
+        if let Ok(number) = input.try(|i| NonNegativeNumber::parse(context, i)) {
             return Ok(GenericLineHeight::Number(number));
         }
-        if let Ok(nlop) = input.r#try(|i| NonNegativeLengthOrPercentage::parse(context, i)) {
+        if let Ok(nlop) = input.try(|i| NonNegativeLengthOrPercentage::parse(context, i)) {
             return Ok(GenericLineHeight::Length(nlop));
         }
         let location = input.current_source_location();
         let ident = input.expect_ident()?;
         match ident {
             ref ident if ident.eq_ignore_ascii_case("normal") => Ok(GenericLineHeight::Normal),
             #[cfg(feature = "gecko")]
             ref ident if ident.eq_ignore_ascii_case("-moz-block-height") =>
@@ -210,17 +210,17 @@ pub struct TextOverflow {
 
 impl Parse for TextOverflow {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<TextOverflow, ParseError<'i>> {
         let first = TextOverflowSide::parse(context, input)?;
         let second = input
-            .r#try(|input| TextOverflowSide::parse(context, input))
+            .try(|input| TextOverflowSide::parse(context, input))
             .ok();
         Ok(TextOverflow { first, second })
     }
 }
 
 impl ToComputedValue for TextOverflow {
     type ComputedValue = ComputedTextOverflow;
 
@@ -290,24 +290,24 @@ macro_rules! impl_text_decoration_line {
         impl Parse for TextDecorationLine {
             /// none | [ underline || overline || line-through || blink ]
             fn parse<'i, 't>(
                 _context: &ParserContext,
                 input: &mut Parser<'i, 't>,
             ) -> Result<TextDecorationLine, ParseError<'i>> {
                 let mut result = TextDecorationLine::NONE;
                 if input
-                    .r#try(|input| input.expect_ident_matching("none"))
+                    .try(|input| input.expect_ident_matching("none"))
                     .is_ok()
                 {
                     return Ok(result);
                 }
 
                 loop {
-                    let result = input.r#try(|input| {
+                    let result = input.try(|input| {
                         let ident = input.expect_ident().map_err(|_| ())?;
                         match_ignore_ascii_case! { ident,
                             $(
                                 $css => {
                                     if result.contains(TextDecorationLine::$ident) {
                                         Err(())
                                     } else {
                                         result.insert(TextDecorationLine::$ident);
@@ -439,17 +439,17 @@ pub enum TextAlign {
 }
 
 impl Parse for TextAlign {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         // MozCenterOrInherit cannot be parsed, only set directly on the elements
-        if let Ok(key) = input.r#try(TextAlignKeyword::parse) {
+        if let Ok(key) = input.try(TextAlignKeyword::parse) {
             return Ok(TextAlign::Keyword(key));
         }
         #[cfg(feature = "gecko")]
         {
             input.expect_ident_matching("match-parent")?;
             return Ok(TextAlign::MatchParent);
         }
         #[cfg(feature = "servo")]
@@ -673,32 +673,32 @@ impl ToComputedValue for TextEmphasisSty
 }
 
 impl Parse for TextEmphasisStyle {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(TextEmphasisStyle::None);
         }
 
-        if let Ok(s) = input.r#try(|i| i.expect_string().map(|s| s.as_ref().to_owned())) {
+        if let Ok(s) = input.try(|i| i.expect_string().map(|s| s.as_ref().to_owned())) {
             // Handle <string>
             return Ok(TextEmphasisStyle::String(s));
         }
 
         // Handle a pair of keywords
-        let mut shape = input.r#try(TextEmphasisShapeKeyword::parse).ok();
-        let fill = input.r#try(TextEmphasisFillMode::parse).ok();
+        let mut shape = input.try(TextEmphasisShapeKeyword::parse).ok();
+        let fill = input.try(TextEmphasisFillMode::parse).ok();
         if shape.is_none() {
-            shape = input.r#try(TextEmphasisShapeKeyword::parse).ok();
+            shape = input.try(TextEmphasisShapeKeyword::parse).ok();
         }
 
         // At least one of shape or fill must be handled
         let keyword_value = match (fill, shape) {
             (Some(fill), Some(shape)) => TextEmphasisKeywordValue::FillAndShape(fill, shape),
             (Some(fill), None) => TextEmphasisKeywordValue::Fill(fill),
             (None, Some(shape)) => TextEmphasisKeywordValue::Shape(shape),
             _ => return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),
@@ -788,17 +788,17 @@ impl TextEmphasisPosition {
 }
 
 impl Parse for TextEmphasisPosition {
     fn parse<'i, 't>(
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         if let Ok(horizontal) =
-            input.r#try(|input| TextEmphasisHorizontalWritingModeValue::parse(input))
+            input.try(|input| TextEmphasisHorizontalWritingModeValue::parse(input))
         {
             let vertical = TextEmphasisVerticalWritingModeValue::parse(input)?;
             Ok(TextEmphasisPosition(horizontal, vertical))
         } else {
             let vertical = TextEmphasisVerticalWritingModeValue::parse(input)?;
             let horizontal = TextEmphasisHorizontalWritingModeValue::parse(input)?;
             Ok(TextEmphasisPosition(horizontal, vertical))
         }
@@ -840,17 +840,17 @@ impl From<TextEmphasisPosition> for u8 {
 /// A specified value for the `-moz-tab-size` property.
 pub type MozTabSize = GenericMozTabSize<NonNegativeNumber, NonNegativeLength>;
 
 impl Parse for MozTabSize {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(number) = input.r#try(|i| NonNegativeNumber::parse(context, i)) {
+        if let Ok(number) = input.try(|i| NonNegativeNumber::parse(context, i)) {
             // Numbers need to be parsed first because `0` must be recognised
             // as the number `0` and not the length `0px`.
             return Ok(GenericMozTabSize::Number(number));
         }
         Ok(GenericMozTabSize::Length(NonNegativeLength::parse(
             context, input,
         )?))
     }
--- a/servo/components/style/values/specified/transform.rs
+++ b/servo/components/style/values/specified/transform.rs
@@ -33,17 +33,17 @@ impl Transform {
     /// https://github.com/w3c/csswg-drafts/issues/1162
     fn parse_internal<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         use style_traits::{Separator, Space};
 
         if input
-            .r#try(|input| input.expect_ident_matching("none"))
+            .try(|input| input.expect_ident_matching("none"))
             .is_ok()
         {
             return Ok(generic::Transform(Vec::new()));
         }
 
         Ok(generic::Transform(Space::parse(input, |input| {
             let function = input.expect_function()?.clone();
             input.parse_nested_block(|input| {
@@ -101,17 +101,17 @@ impl Transform {
                             m11, m12, m13, m14,
                             m21, m22, m23, m24,
                             m31, m32, m33, m34,
                             m41, m42, m43, m44,
                         }))
                     },
                     "translate" => {
                         let sx = specified::LengthOrPercentage::parse(context, input)?;
-                        if input.r#try(|input| input.expect_comma()).is_ok() {
+                        if input.try(|input| input.expect_comma()).is_ok() {
                             let sy = specified::LengthOrPercentage::parse(context, input)?;
                             Ok(generic::TransformOperation::Translate(sx, Some(sy)))
                         } else {
                             Ok(generic::TransformOperation::Translate(sx, None))
                         }
                     },
                     "translatex" => {
                         let tx = specified::LengthOrPercentage::parse(context, input)?;
@@ -130,17 +130,17 @@ impl Transform {
                         input.expect_comma()?;
                         let ty = specified::LengthOrPercentage::parse(context, input)?;
                         input.expect_comma()?;
                         let tz = specified::Length::parse(context, input)?;
                         Ok(generic::TransformOperation::Translate3D(tx, ty, tz))
                     },
                     "scale" => {
                         let sx = Number::parse(context, input)?;
-                        if input.r#try(|input| input.expect_comma()).is_ok() {
+                        if input.try(|input| input.expect_comma()).is_ok() {
                             let sy = Number::parse(context, input)?;
                             Ok(generic::TransformOperation::Scale(sx, Some(sy)))
                         } else {
                             Ok(generic::TransformOperation::Scale(sx, None))
                         }
                     },
                     "scalex" => {
                         let sx = Number::parse(context, input)?;
@@ -186,17 +186,17 @@ impl Transform {
                         let az = Number::parse(context, input)?;
                         input.expect_comma()?;
                         let theta = specified::Angle::parse_with_unitless(context, input)?;
                         // TODO(gw): Check that the axis can be normalized.
                         Ok(generic::TransformOperation::Rotate3D(ax, ay, az, theta))
                     },
                     "skew" => {
                         let ax = specified::Angle::parse_with_unitless(context, input)?;
-                        if input.r#try(|input| input.expect_comma()).is_ok() {
+                        if input.try(|input| input.expect_comma()).is_ok() {
                             let ay = specified::Angle::parse_with_unitless(context, input)?;
                             Ok(generic::TransformOperation::Skew(ax, Some(ay)))
                         } else {
                             Ok(generic::TransformOperation::Skew(ax, None))
                         }
                     },
                     "skewx" => {
                         let theta = specified::Angle::parse_with_unitless(context, input)?;
@@ -243,53 +243,53 @@ pub enum OriginComponent<S> {
 
 impl Parse for TransformOrigin {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let parse_depth = |input: &mut Parser| {
             input
-                .r#try(|i| Length::parse(context, i))
+                .try(|i| Length::parse(context, i))
                 .unwrap_or(Length::from_px(0.))
         };
-        match input.r#try(|i| OriginComponent::parse(context, i)) {
+        match input.try(|i| OriginComponent::parse(context, i)) {
             Ok(x_origin @ OriginComponent::Center) => {
-                if let Ok(y_origin) = input.r#try(|i| OriginComponent::parse(context, i)) {
+                if let Ok(y_origin) = input.try(|i| OriginComponent::parse(context, i)) {
                     let depth = parse_depth(input);
                     return Ok(Self::new(x_origin, y_origin, depth));
                 }
                 let y_origin = OriginComponent::Center;
-                if let Ok(x_keyword) = input.r#try(X::parse) {
+                if let Ok(x_keyword) = input.try(X::parse) {
                     let x_origin = OriginComponent::Side(x_keyword);
                     let depth = parse_depth(input);
                     return Ok(Self::new(x_origin, y_origin, depth));
                 }
                 let depth = Length::from_px(0.);
                 return Ok(Self::new(x_origin, y_origin, depth));
             },
             Ok(x_origin) => {
-                if let Ok(y_origin) = input.r#try(|i| OriginComponent::parse(context, i)) {
+                if let Ok(y_origin) = input.try(|i| OriginComponent::parse(context, i)) {
                     let depth = parse_depth(input);
                     return Ok(Self::new(x_origin, y_origin, depth));
                 }
                 let y_origin = OriginComponent::Center;
                 let depth = Length::from_px(0.);
                 return Ok(Self::new(x_origin, y_origin, depth));
             },
             Err(_) => {},
         }
         let y_keyword = Y::parse(input)?;
         let y_origin = OriginComponent::Side(y_keyword);
-        if let Ok(x_keyword) = input.r#try(X::parse) {
+        if let Ok(x_keyword) = input.try(X::parse) {
             let x_origin = OriginComponent::Side(x_keyword);
             let depth = parse_depth(input);
             return Ok(Self::new(x_origin, y_origin, depth));
         }
-        if input.r#try(|i| i.expect_ident_matching("center")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("center")).is_ok() {
             let x_origin = OriginComponent::Center;
             let depth = parse_depth(input);
             return Ok(Self::new(x_origin, y_origin, depth));
         }
         let x_origin = OriginComponent::Center;
         let depth = Length::from_px(0.);
         Ok(Self::new(x_origin, y_origin, depth))
     }
@@ -298,20 +298,20 @@ impl Parse for TransformOrigin {
 impl<S> Parse for OriginComponent<S>
 where
     S: Parse,
 {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("center")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("center")).is_ok() {
             return Ok(OriginComponent::Center);
         }
-        if let Ok(lop) = input.r#try(|i| LengthOrPercentage::parse(context, i)) {
+        if let Ok(lop) = input.try(|i| LengthOrPercentage::parse(context, i)) {
             return Ok(OriginComponent::Length(lop));
         }
         let keyword = S::parse(context, input)?;
         Ok(OriginComponent::Side(keyword))
     }
 }
 
 impl<S> ToComputedValue for OriginComponent<S>
@@ -348,21 +348,21 @@ impl<S> OriginComponent<S> {
 /// A specified CSS `rotate`
 pub type Rotate = generic::Rotate<Number, Angle>;
 
 impl Parse for Rotate {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(generic::Rotate::None);
         }
 
-        if let Ok(rx) = input.r#try(|i| Number::parse(context, i)) {
+        if let Ok(rx) = input.try(|i| Number::parse(context, i)) {
             // 'rotate: <number>{3} <angle>'
             let ry = Number::parse(context, input)?;
             let rz = Number::parse(context, input)?;
             let angle = specified::Angle::parse(context, input)?;
             return Ok(generic::Rotate::Rotate3D(rx, ry, rz, angle));
         }
 
         // 'rotate: <angle>'
@@ -374,23 +374,23 @@ impl Parse for Rotate {
 /// A specified CSS `translate`
 pub type Translate = generic::Translate<LengthOrPercentage, Length>;
 
 impl Parse for Translate {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(generic::Translate::None);
         }
 
         let tx = specified::LengthOrPercentage::parse(context, input)?;
-        if let Ok(ty) = input.r#try(|i| specified::LengthOrPercentage::parse(context, i)) {
-            if let Ok(tz) = input.r#try(|i| specified::Length::parse(context, i)) {
+        if let Ok(ty) = input.try(|i| specified::LengthOrPercentage::parse(context, i)) {
+            if let Ok(tz) = input.try(|i| specified::Length::parse(context, i)) {
                 // 'translate: <length-percentage> <length-percentage> <length>'
                 return Ok(generic::Translate::Translate3D(tx, ty, tz));
             }
 
             // translate: <length-percentage> <length-percentage>'
             return Ok(generic::Translate::Translate(tx, ty));
         }
 
@@ -405,23 +405,23 @@ impl Parse for Translate {
 /// A specified CSS `scale`
 pub type Scale = generic::Scale<Number>;
 
 impl Parse for Scale {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("none")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("none")).is_ok() {
             return Ok(generic::Scale::None);
         }
 
         let sx = Number::parse(context, input)?;
-        if let Ok(sy) = input.r#try(|i| Number::parse(context, i)) {
-            if let Ok(sz) = input.r#try(|i| Number::parse(context, i)) {
+        if let Ok(sy) = input.try(|i| Number::parse(context, i)) {
+            if let Ok(sz) = input.try(|i| Number::parse(context, i)) {
                 // 'scale: <number> <number> <number>'
                 return Ok(generic::Scale::Scale3D(sx, sy, sz));
             }
 
             // 'scale: <number> <number>'
             return Ok(generic::Scale::Scale(sx, sy));
         }
 
--- a/servo/components/style/values/specified/ui.rs
+++ b/servo/components/style/values/specified/ui.rs
@@ -27,17 +27,17 @@ pub type CursorImage = generics::CursorI
 impl Parse for Cursor {
     /// cursor: [<url> [<number> <number>]?]# [auto | default | ...]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let mut images = vec![];
         loop {
-            match input.r#try(|input| CursorImage::parse(context, input)) {
+            match input.try(|input| CursorImage::parse(context, input)) {
                 Ok(image) => images.push(image),
                 Err(_) => break,
             }
             input.expect_comma()?;
         }
         Ok(Self {
             images: images.into_boxed_slice(),
             keyword: CursorKind::parse(context, input)?,
@@ -59,17 +59,17 @@ impl Parse for CursorKind {
 
 impl Parse for CursorImage {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         Ok(Self {
             url: SpecifiedImageUrl::parse(context, input)?,
-            hotspot: match input.r#try(|input| Number::parse(context, input)) {
+            hotspot: match input.try(|input| Number::parse(context, input)) {
                 Ok(number) => Some((number, Number::parse(context, input)?)),
                 Err(_) => None,
             },
         })
     }
 }
 
 /// Specified value of `-moz-force-broken-image-icon`
@@ -126,17 +126,17 @@ impl From<MozForceBrokenImageIcon> for u
 /// A specified value for `scrollbar-color` property
 pub type ScrollbarColor = generics::ScrollbarColor<Color>;
 
 impl Parse for ScrollbarColor {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if input.r#try(|i| i.expect_ident_matching("auto")).is_ok() {
+        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
             return Ok(generics::ScrollbarColor::Auto);
         }
         Ok(generics::ScrollbarColor::Colors {
             thumb: Color::parse(context, input)?,
             track: Color::parse(context, input)?,
         })
     }
 }
--- a/servo/components/style_traits/values.rs
+++ b/servo/components/style_traits/values.rs
@@ -319,17 +319,17 @@ impl Separator for Space {
     ) -> Result<Vec<T>, ParseError<'i, E>>
     where
         F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
     {
         input.skip_whitespace(); // Unnecessary for correctness, but may help try() rewind less.
         let mut results = vec![parse_one(input)?];
         loop {
             input.skip_whitespace(); // Unnecessary for correctness, but may help try() rewind less.
-            if let Ok(item) = input.r#try(&mut parse_one) {
+            if let Ok(item) = input.try(&mut parse_one) {
                 results.push(item);
             } else {
                 return Ok(results);
             }
         }
     }
 }
 
@@ -345,19 +345,19 @@ impl Separator for CommaWithSpace {
     where
         F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
     {
         input.skip_whitespace(); // Unnecessary for correctness, but may help try() rewind less.
         let mut results = vec![parse_one(input)?];
         loop {
             input.skip_whitespace(); // Unnecessary for correctness, but may help try() rewind less.
             let comma_location = input.current_source_location();
-            let comma = input.r#try(|i| i.expect_comma()).is_ok();
+            let comma = input.try(|i| i.expect_comma()).is_ok();
             input.skip_whitespace(); // Unnecessary for correctness, but may help try() rewind less.
-            if let Ok(item) = input.r#try(&mut parse_one) {
+            if let Ok(item) = input.try(&mut parse_one) {
                 results.push(item);
             } else if comma {
                 return Err(comma_location.new_unexpected_token_error(Token::Comma));
             } else {
                 break;
             }
         }
         Ok(results)