Fixed missing parameter ParsingException constructor and fixed "((int) 0)" not parsing correctly

Author: Timo Lehnertz

src/parsing/FunctionParser.php

@@ -1,5 +1,7 @@
 <?php
-declare(strict_types = 1);
+
+declare(strict_types=1);
+
 namespace TimoLehnertz\formula\parsing;
 
 use TimoLehnertz\formula\expression\FunctionExpression;
@@ -12,81 +14,81 @@
 
 /**
  * @author Timo Lehnertz
+ * <Function value> ::= <Type>? <FunctionArguments> "->" <Expression> | ("{" <CodeBlock> "}")
  */
 class FunctionParser extends Parser {
 
   private readonly bool $parseStatement;
 
   public function __construct(bool $parseStatement) {
-    if($parseStatement) {
-      parent::__construct('function statement');
-    } else {
-      parent::__construct('function value');
-    }
+    parent::__construct($parseStatement ? 'function statement' : 'function value');
     $this->parseStatement = $parseStatement;
   }
 
   protected function parsePart(Token $firstToken): ParserReturn {
-    // var_dump('Moin');
-    if(!$this->parseStatement) {
+    if (!$this->parseStatement) {
       try {
         $parsedReturnType = (new TypeParser(false))->parse($firstToken);
         $token = $parsedReturnType->nextToken;
-      } catch(ParsingException | ParsingSkippedException $e) {
+      } catch (ParsingException | ParsingSkippedException) {
         $parsedReturnType = null;
         $token = $firstToken;
       }
     } else {
-      if($firstToken->id === Token::KEYWORD_VOID) {
+      if ($firstToken->id === Token::KEYWORD_VOID) {
         $parsedReturnType = new ParserReturn(new VoidType(), $firstToken->next());
       } else {
         $parsedReturnType = (new TypeParser(false))->parse($firstToken);
       }
       $token = $parsedReturnType->nextToken;
     }
-    if($token === null) {
+    if ($token === null) {
       throw new ParsingSkippedException();
     }
-    if($this->parseStatement) {
-      if($token->id !== Token::IDENTIFIER) {
+    if ($this->parseStatement) {
+      if ($token->id !== Token::IDENTIFIER) {
         throw new ParsingSkippedException();
       }
       $identifier = $token->value;
       $token = $token->next();
-      if($token === null) {
+      if ($token === null) {
         throw new ParsingSkippedException();
       }
     }
     $functionArgumentParser = new EnumeratedParser('Function arguments', new InnerFunctionArgumentParser(false), Token::BRACKETS_OPEN, Token::COMMA, Token::BRACKETS_CLOSED, false, true);
-    $parsedArguments = $functionArgumentParser->parse($token);
+    try {
+      $parsedArguments = $functionArgumentParser->parse($token);
+    } catch(ParsingException) {
+      throw new ParsingSkippedException();
+    }
     $token = $parsedArguments->nextToken;
     $normalArgs = [];
     $vArg = null;
-    for($i = 0;$i < count($parsedArguments->parsed);$i++) {
+    for ($i = 0; $i < count($parsedArguments->parsed); $i++) {
       $arg = $parsedArguments->parsed[$i];
-      if($arg instanceof InnerFunctionArgument) {
+      if ($arg instanceof InnerFunctionArgument) {
         $normalArgs[] = $arg;
-      } else if($arg instanceof InnerVargFunctionArgument) {
+      } else if ($arg instanceof InnerVargFunctionArgument) {
         $vArg = $arg;
-        if($i !== count($parsedArguments->parsed) - 1) {
+        if ($i !== count($parsedArguments->parsed) - 1) {
           throw new ParsingException(ParsingException::ERROR_VARG_NOT_LAST);
         }
       }
     }
-    if(!$this->parseStatement) {
+    if (!$this->parseStatement) {
       try {
         $parsedCodeBlock = (new ExpressionFunctionBodyParser())->parse($token);
-      } catch(ParsingSkippedException $e) {
+      } catch (ParsingSkippedException $e) {
         $parsedCodeBlock = (new CodeBlockParser(false, false))->parse($token);
-        if($parsedReturnType === null) {
+        if ($parsedReturnType === null) {
           throw new ParsingException(ParsingException::ERROR_UNEXPECTED_TOKEN, $token, 'Function requires return type');
         }
       }
     } else {
       $parsedCodeBlock = (new CodeBlockParser(false, false))->parse($token);
     }
     $innerArgs = new InnerFunctionArgumentList($normalArgs, $vArg);
-    if($this->parseStatement) {
+    if ($this->parseStatement) {
       $parsed = new FunctionStatement($parsedReturnType->parsed, $identifier, $innerArgs, $parsedCodeBlock->parsed);
     } else {
       $parsed = new FunctionExpression($parsedReturnType?->parsed ?? null, $innerArgs, $parsedCodeBlock->parsed);

src/parsing/InnerFunctionArgumentParser.php

@@ -32,13 +32,13 @@ protected function parsePart(Token $firstToken): ParserReturn {
       $token = $token->requireNext();
     }
     if($token->id !== Token::IDENTIFIER) {
-      throw new ParsingException(ParsingException::ERROR_UNEXPECTED_TOKEN, 'Expected identifier');
+      throw new ParsingException(ParsingException::ERROR_UNEXPECTED_TOKEN, $token, 'Expected identifier');
     }
     $identifier = $token->value;
     $parsedExpression = null;
     if($token->hasNext() && $token->next()->id === Token::ASSIGNMENT) {
       if($isVarg) {
-        throw new ParsingException(ParsingException::ERROR_UNEXPECTED_TOKEN, 'Vargs can\'t have a default initilizer');
+        throw new ParsingException(ParsingException::ERROR_UNEXPECTED_TOKEN, $token, 'Vargs can\'t have a default initilizer');
       }
       $parsedExpression = (new ExpressionParser())->parse($token->next()->next());
       $token = $parsedExpression->nextToken;

test/FormulaTest.php

@@ -244,7 +244,7 @@ public function testFunctionWithNoParams(): void {
 
   public function testVoidFunction(): void {
     new Formula('void r() {}');
-    $this->assertTrue(true); // assert no exception
+    $this->assertTrue(true); // assert no exception was thrown
   }
 
   public function testRecursiveFunction(): void {
@@ -261,4 +261,9 @@ public function testAnonymousVoidFunction(): void {
     $formula = new Formula('int b = 0;function(int) -> void a = void (int a) {b = a;}; a(1); return b;');
     $this->assertEquals(1, $formula->calculate()->toPHPValue());
   }
+
+  public function testGetNthBit(): void {
+    $formula = new Formula('((((int) 0b011) >> 1) & 1)');
+    $this->assertEquals(1, $formula->calculate()->toPHPValue());
+  }
 }