clippy and fmt issues

sway-ast/src/ty/mod.rs

@@ -43,9 +43,11 @@ impl Spanned for Ty {
             Ty::Infer { underscore_token } => underscore_token.span(),
             Ty::Ptr { ptr_token, ty } => Span::join(ptr_token.span(), &ty.span()),
             Ty::Slice { slice_token, ty } => {
-                let span = slice_token.as_ref().map(|s| Span::join(s.span(), &ty.span()));
+                let span = slice_token
+                    .as_ref()
+                    .map(|s| Span::join(s.span(), &ty.span()));
                 span.unwrap_or_else(|| ty.span())
-            },
+            }
             Ty::Ref {
                 ampersand_token,
                 mut_token: _,

sway-parse/src/item/item_impl.rs

@@ -90,11 +90,23 @@ mod tests {
     fn parse_impl_slice() {
         // deprecated syntax
         let item = parse::<ItemImpl>("impl __slice[T] {}");
-        assert_matches!(item.ty, Ty::Slice { slice_token: Some(..), ty: _ });
+        assert_matches!(
+            item.ty,
+            Ty::Slice {
+                slice_token: Some(..),
+                ty: _
+            }
+        );
 
         // "new" syntax
         let item = parse::<ItemImpl>("impl [T] {}");
-        assert_matches!(item.ty, Ty::Slice { slice_token: None, ty: _ });
+        assert_matches!(
+            item.ty,
+            Ty::Slice {
+                slice_token: None,
+                ty: _
+            }
+        );
 
         let item = parse::<ItemImpl>("impl &[T] {}");
         assert_matches!(item.ty, Ty::Ref { ty, .. } if matches!(&*ty, Ty::Slice { .. }));

sway-parse/src/parser.rs

@@ -208,11 +208,14 @@ impl<'a, 'e> Parser<'a, 'e> {
     }
 
     /// This method is useful if `T` does not impl `ParseToEnd`
-    pub fn try_parse_and_check_empty<T: Parse>(mut self, append_diagnostics: bool) -> ParseResult<Option<(T, ParserConsumed<'a>)>> {
+    pub fn try_parse_and_check_empty<T: Parse>(
+        mut self,
+        append_diagnostics: bool,
+    ) -> ParseResult<Option<(T, ParserConsumed<'a>)>> {
         let value = self.try_parse(append_diagnostics)?;
         match self.check_empty() {
             Some(consumed) => Ok(Some((value, consumed))),
-            None => return Ok(None),
+            None => Ok(None),
         }
     }
 
@@ -233,20 +236,18 @@ impl<'a, 'e> Parser<'a, 'e> {
     }
 
     /// Do not advance the parser on failure
-    pub fn try_parse_to_end<T: ParseToEnd>(&mut self, append_diagnostics: bool) -> ParseResult<(T, ParserConsumed<'a>)> {
+    pub fn try_parse_to_end<T: ParseToEnd>(
+        &mut self,
+        append_diagnostics: bool,
+    ) -> ParseResult<(T, ParserConsumed<'a>)> {
         let handler = Handler::default();
         let fork = Parser {
             token_trees: self.token_trees,
             full_span: self.full_span.clone(),
             handler: &handler,
             check_double_underscore: self.check_double_underscore,
         };
-        let r = match T::parse_to_end(fork) {
-            Ok(result) => {
-                Ok(result)
-            }
-            Err(err) => Err(err),
-        };
+        let r = T::parse_to_end(fork);
         if append_diagnostics {
             self.handler.append(handler);
         }

sway-parse/src/test_utils.rs

@@ -24,9 +24,7 @@ where
 {
     let handler = <_>::default();
     let ts = crate::token::lex(&handler, &Arc::from(input), 0, input.len(), None).unwrap();
-    let r = Parser::new(&handler, &ts)
-        .parse_to_end()
-        .map(|(m, _)| m);
+    let r = Parser::new(&handler, &ts).parse_to_end().map(|(m, _)| m);
 
     if handler.has_errors() || handler.has_warnings() {
         panic!("{:?}", handler.consume());

sway-parse/src/ty/mod.rs

@@ -33,20 +33,17 @@ impl Parse for Ty {
         if let Some((mut inner_parser, span)) = parser.enter_delimited(Delimiter::Bracket) {
             // array like [type; len]
             if let Ok((array, _)) = inner_parser.try_parse_to_end::<TyArrayDescriptor>(false) {
-                return Ok(Ty::Array(SquareBrackets { 
-                    inner: array, 
-                    span
-                }));
+                return Ok(Ty::Array(SquareBrackets { inner: array, span }));
             }
 
             // slice like [type]
             if let Ok(Some((ty, _))) = inner_parser.try_parse_and_check_empty::<Ty>(false) {
-                return Ok(Ty::Slice { 
+                return Ok(Ty::Slice {
                     slice_token: None,
-                    ty: SquareBrackets{
+                    ty: SquareBrackets {
                         inner: Box::new(ty),
                         span,
-                    }
+                    },
                 });
             }
         }
@@ -78,7 +75,10 @@ impl Parse for Ty {
             let ty = SquareBrackets::<Box<Ty>>::parse_all_inner(parser, |mut parser| {
                 parser.emit_error(ParseErrorKind::UnexpectedTokenAfterSliceType)
             })?;
-            return Ok(Ty::Slice { slice_token: Some(slice_token), ty });
+            return Ok(Ty::Slice {
+                slice_token: Some(slice_token),
+                ty,
+            });
         }
 
         if let Some(ampersand_token) = parser.take() {
@@ -90,7 +90,7 @@ impl Parse for Ty {
                 ty,
             });
         }
-        
+
         if let Some(bang_token) = parser.take() {
             return Ok(Ty::Never { bang_token });
         }

swayfmt/src/utils/language/ty.rs

@@ -117,15 +117,20 @@ fn format_ptr(
 
 fn format_slice(
     formatted_code: &mut FormattedCode,
-    slice_token: SliceToken,
+    slice_token: Option<SliceToken>,
     ty: SquareBrackets<Box<Ty>>,
 ) -> Result<(), FormatterError> {
-    write!(
-        formatted_code,
-        "{}[{}]",
-        slice_token.span().as_str(),
-        ty.into_inner().span().as_str()
-    )?;
+    if let Some(slice_token) = slice_token {
+        write!(
+            formatted_code,
+            "{}[{}]",
+            slice_token.span().as_str(),
+            ty.into_inner().span().as_str()
+        )?;
+    } else {
+        write!(formatted_code, "[{}]", ty.into_inner().span().as_str())?;
+    }
+
     Ok(())
 }
 
@@ -202,7 +207,11 @@ impl LeafSpans for Ty {
                 collected_spans
             }
             Ty::Slice { slice_token, ty } => {
-                let mut collected_spans = vec![ByteSpan::from(slice_token.span())];
+                let mut collected_spans = if let Some(slice_token) = slice_token {
+                    vec![ByteSpan::from(slice_token.span())]
+                } else {
+                    vec![]
+                };
                 collected_spans.append(&mut ty.leaf_spans());
                 collected_spans
             }