1 files changed, 21 insertions, 21 deletions

diff --git a/vendor/time-macros/src/format_description/ast.rs b/vendor/time-macros/src/format_description/ast.rs
index 497c8965d..f33c6d433 100644
--- a/vendor/time-macros/src/format_description/ast.rs
+++ b/vendor/time-macros/src/format_description/ast.rs
@@ -127,24 +127,24 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
 ) -> Result<Item<'a>, Error> {
     let leading_whitespace = tokens.next_if_whitespace();
 
-    guard!(let Some(name) = tokens.next_if_not_whitespace() else {
+    let Some(name) = tokens.next_if_not_whitespace() else {
         let span = match leading_whitespace {
             Some(Spanned { value: _, span }) => span,
             None => opening_bracket.to(opening_bracket),
         };
         return Err(span.error("expected component name"));
-    });
+    };
 
     if *name == b"optional" {
-        guard!(let Some(whitespace) = tokens.next_if_whitespace() else {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
             return Err(name.span.error("expected whitespace after `optional`"));
-        });
+        };
 
         let nested = parse_nested::<_, VERSION>(whitespace.span.end, tokens)?;
 
-        guard!(let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
             return Err(opening_bracket.error("unclosed bracket"));
-        });
+        };
 
         return Ok(Item::Optional {
             opening_bracket,
@@ -157,18 +157,18 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
     }
 
     if *name == b"first" {
-        guard!(let Some(whitespace) = tokens.next_if_whitespace() else {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
             return Err(name.span.error("expected whitespace after `first`"));
-        });
+        };
 
         let mut nested_format_descriptions = Vec::new();
         while let Ok(description) = parse_nested::<_, VERSION>(whitespace.span.end, tokens) {
             nested_format_descriptions.push(description);
         }
 
-        guard!(let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
             return Err(opening_bracket.error("unclosed bracket"));
-        });
+        };
 
         return Ok(Item::First {
             opening_bracket,
@@ -182,7 +182,7 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
 
     let mut modifiers = Vec::new();
     let trailing_whitespace = loop {
-        guard!(let Some(whitespace) = tokens.next_if_whitespace() else { break None });
+        let Some(whitespace) = tokens.next_if_whitespace() else { break None };
 
         if let Some(location) = tokens.next_if_opening_bracket() {
             return Err(location
@@ -190,13 +190,13 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
                 .error("modifier must be of the form `key:value`"));
         }
 
-        guard!(let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else {
+        let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else {
             break Some(whitespace);
-        });
+        };
 
-        guard!(let Some(colon_index) = value.iter().position(|&b| b == b':') else {
+        let Some(colon_index) = value.iter().position(|&b| b == b':') else {
             return Err(span.error("modifier must be of the form `key:value`"));
-        });
+        };
         let key = &value[..colon_index];
         let value = &value[colon_index + 1..];
 
@@ -215,9 +215,9 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
         });
     };
 
-    guard!(let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
         return Err(opening_bracket.error("unclosed bracket"));
-    });
+    };
 
     Ok(Item::Component {
         _opening_bracket: unused(opening_bracket),
@@ -233,13 +233,13 @@ fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const V
     last_location: Location,
     tokens: &mut lexer::Lexed<I>,
 ) -> Result<NestedFormatDescription<'a>, Error> {
-    guard!(let Some(opening_bracket) = tokens.next_if_opening_bracket() else {
+    let Some(opening_bracket) = tokens.next_if_opening_bracket() else {
         return Err(last_location.error("expected opening bracket"));
-    });
+    };
     let items = parse_inner::<_, true, VERSION>(tokens).collect::<Result<_, _>>()?;
-    guard!(let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
         return Err(opening_bracket.error("unclosed bracket"));
-    });
+    };
     let trailing_whitespace = tokens.next_if_whitespace();
 
     Ok(NestedFormatDescription {