cargo fmt

wright/src/parser.rs

@@ -3,11 +3,14 @@
 //! [AST]: crate::ast
 //! [Token]: crate::lexer::token::Token
 
-use std::collections::VecDeque;
 use error::ParserError;
+use std::collections::VecDeque;
 
-use crate::{lexer::token::{Token, TokenTy}, source_tracking::fragment::Fragment};
 use super::lexer::Lexer;
+use crate::{
+    lexer::token::{Token, TokenTy},
+    source_tracking::fragment::Fragment,
+};
 
 pub mod error;
 mod identifier;
@@ -32,7 +35,9 @@ impl Parser {
 
     /// Get the next [Token] from this [Parser]. This may be a clone of a token that's already been peeked.
     pub fn next(&mut self) -> Option<Token> {
-        self.lookahead.pop_front().or_else(|| self.lexer.next_token())
+        self.lookahead
+            .pop_front()
+            .or_else(|| self.lexer.next_token())
     }
 
     /// Peek at the next token from the [Lexer] (cached in the lookahead queue if peeked before).
@@ -54,8 +59,8 @@ impl Parser {
         &self.lexer
     }
 
-    /// Lookahead `k` [Token]s. 
-    /// 
+    /// Lookahead `k` [Token]s.
+    ///
     /// If `k == 0` then this is effectively peeking at the next [Token] from the wrapped [Lexer].
     pub fn lookahead(&mut self, k: usize) -> Option<&Token> {
         while self.lookahead.len() <= k {
@@ -68,7 +73,8 @@ impl Parser {
     /// Get the next [Token] from this parser if its [Token::variant] is the given `token_ty`.
     pub fn next_if_is(&mut self, token_ty: TokenTy) -> Option<Token> {
         // Peeking successfully first means that the lookahead vec will never be empty here.
-        (self.peek()?.variant == token_ty).then(|| unsafe { self.lookahead.pop_front().unwrap_unchecked() })
+        (self.peek()?.variant == token_ty)
+            .then(|| unsafe { self.lookahead.pop_front().unwrap_unchecked() })
     }
 
     /// Peek at the next [Token], remove it if it's a [TokenTy::Whitespace].

wright/src/parser/error.rs

@@ -26,8 +26,12 @@ impl ParserErrorKind {
         match self {
             ExpectedIdentifier => "expected identifier",
             ExpectedPath => "expected path or identifier",
-            UnterminatedMultilineCommentEncountered => "encountered unterminated multiline comment while parsing",
-            UnterminatedStringLiteralEncountered => "encountered unterminated string literal while parsing",
+            UnterminatedMultilineCommentEncountered => {
+                "encountered unterminated multiline comment while parsing"
+            }
+            UnterminatedStringLiteralEncountered => {
+                "encountered unterminated string literal while parsing"
+            }
         }
     }
 
@@ -55,9 +59,7 @@ pub struct ParserError {
 impl ParserError {
     /// Turn this parser error into a full blown compiler error.
     pub fn as_diagnostic(self) -> Diagnostic {
-        let description = self
-            .kind
-            .describe();
+        let description = self.kind.describe();
 
         let mut diagnostic = Diagnostic::error()
             .with_code(self.kind.error_code_string())

wright/src/parser/identifier.rs

@@ -25,9 +25,8 @@ impl Parse for Identifier {
                     kind: ParserErrorKind::ExpectedIdentifier,
                     location: parser.lexer.remaining.clone(),
                     help: Some("found end of source".into()),
-                })
-
-            }
+                }),
+            },
         }
     }
 }

wright/src/parser/path.rs

@@ -16,14 +16,12 @@ impl Parse for Path {
 
 /// Parse the first (and possibly only) [Identifier] in the [Path].
 fn parse_head(parser: &mut Parser) -> Result<Identifier, ParserError> {
-    Identifier::parse(parser)
-        .map_err(|mut err| {
-            err.kind = ParserErrorKind::ExpectedPath;
-            err
-        })
+    Identifier::parse(parser).map_err(|mut err| {
+        err.kind = ParserErrorKind::ExpectedPath;
+        err
+    })
 }
 
-
 // /// Parse a path (`head::tail`) in source code.
 // pub fn parse_path<'src>(parser_state: &mut ParserState<'src>) -> NodeParserResult<Path<'src>> {
 //     // Get the initial index to make metadata at the end.

wright/src/parser/whitespace.rs

@@ -1,14 +1,21 @@
 //! Utilities for parsing through whitespace.
 
-use crate::lexer::{token::{Token, TokenTy}, Lexer};
+use crate::lexer::{
+    token::{Token, TokenTy},
+    Lexer,
+};
 use std::mem;
 
 /// Consume and ignore a [TokenTy::Whitespace] from the front of the lexer.
 /// If there is not one, do nothing.
 pub fn optional_whitespace(lexer: &mut Lexer) {
     let mut fork = lexer.fork();
 
-    if let Some(Token { variant: TokenTy::Whitespace, .. }) = fork.next_token() {
+    if let Some(Token {
+        variant: TokenTy::Whitespace,
+        ..
+    }) = fork.next_token()
+    {
         // Replace the original lexer with the fork.
         let _ = mem::replace(lexer, fork);
     }