From 7fbe47f0bb189bf440b710556102bdf407d349f1 Mon Sep 17 00:00:00 2001
From: mars <mars@tebibyte.media>
Date: Wed, 2 Mar 2022 15:01:55 -0700
Subject: [PATCH] Fix spelling of parEntheses

---
 src/lexer.rs |  4 ++--
 src/parse.rs | 22 +++++++++++-----------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/lexer.rs b/src/lexer.rs
index 36fc8cf..9ab735f 100644
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -27,8 +27,8 @@ pub enum Token {
     // separators
     #[token("{")] BraceOpen,
     #[token("}")] BraceClose,
-    #[token("(")] ParanOpen,
-    #[token(")")] ParanClose,
+    #[token("(")] ParenOpen,
+    #[token(")")] ParenClose,
     #[token(";")] Semicolon,
     #[token(",")] Comma,
     #[token(".")] Dot,
diff --git a/src/parse.rs b/src/parse.rs
index 2e5468f..db18cf6 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -227,7 +227,7 @@ pub struct FnSig<'a> {
 
 impl<'a> FnSig<'a> {
     pub fn build(lexer: &mut Lexer<'a>) -> (Self, Token) {
-        lexer.eat_expect(Token::ParanOpen);
+        lexer.eat_expect(Token::ParenOpen);
         let mut args = Vec::new();
 
         loop {
@@ -241,7 +241,7 @@ impl<'a> FnSig<'a> {
                         type_name,
                         name: None,
                     }),
-                    Token::ParanClose => {
+                    Token::ParenClose => {
                         args.push(FnArg {
                             type_name,
                             name: None,
@@ -251,8 +251,8 @@ impl<'a> FnSig<'a> {
                     _ => lexer.panic_message("Unexpected token"),
                 },
                 Err(Some(Token::Comma)) => {}
-                Err(Some(Token::ParanClose)) => break,
-                _ => lexer.panic_message("Expected comma, type, or closing parantheses"),
+                Err(Some(Token::ParenClose)) => break,
+                _ => lexer.panic_message("Expected comma, type, or closing parentheses"),
             }
         }
 
@@ -374,10 +374,10 @@ impl<'a> Expr<'a> {
         let lhs = match tok {
             Token::Identifier => Self::Local(lexer.slice()),
             Token::Dot => Self::SelfMember(lexer.eat_expect_id()),
-            Token::ParanOpen => {
+            Token::ParenOpen => {
                 let (inner, next) = Self::build(lexer);
-                if next != Token::ParanClose {
-                    lexer.panic_message("Expected closing parantheses");
+                if next != Token::ParenClose {
+                    lexer.panic_message("Expected closing parentheses");
                 }
                 Self::Group(Box::new(inner.unwrap()))
             }
@@ -390,7 +390,7 @@ impl<'a> Expr<'a> {
             Token::StringLiteral => Self::Literal(Literal::String(lexer.slice())),
             Token::True => Self::Literal(Literal::Boolean(true)),
             Token::False => Self::Literal(Literal::Boolean(false)),
-            Token::Semicolon | Token::BraceClose | Token::ParanClose => return (None, tok),
+            Token::Semicolon | Token::BraceClose | Token::ParenClose => return (None, tok),
             _ => lexer.panic_message("Unexpected token"),
         };
 
@@ -409,7 +409,7 @@ impl<'a> Expr<'a> {
                     let expr = Self::Member(member, Box::new(lhs));
                     lhs = expr;
                 }
-                Token::ParanOpen => lhs = Self::FnCall(Box::new(lhs), Self::eat_args(lexer)),
+                Token::ParenOpen => lhs = Self::FnCall(Box::new(lhs), Self::eat_args(lexer)),
                 _ => {
                     if let Some(op) = BinaryOp::from_token(tok) {
                         match Self::build(lexer) {
@@ -436,11 +436,11 @@ impl<'a> Expr<'a> {
         loop {
             match Self::build(lexer) {
                 (Some(arg), Token::Comma) => args.push(arg),
-                (Some(arg), Token::ParanClose) => {
+                (Some(arg), Token::ParenClose) => {
                     args.push(arg);
                     break;
                 }
-                (None, Token::ParanClose) => break,
+                (None, Token::ParenClose) => break,
                 _ => lexer.panic_message("Unexpected token"),
             }
         }