...

compiler/NubLang/Parsing/Parser.cs

@@ -154,9 +154,10 @@ public sealed class Parser
         var signature = ParseFuncSignature();
 
         BlockSyntax? body = null;
-        if (CurrentToken is SymbolToken { Symbol: Symbol.OpenBrace })
+        var bodyStartIndex = _tokenIndex;
+        if (TryExpectSymbol(Symbol.OpenBrace))
         {
-            body = ParseBlock();
+            body = ParseBlock(bodyStartIndex);
         }
 
         return new FuncSyntax(GetTokens(startIndex), name.Value, exported, externSymbol, signature, body);
@@ -213,28 +214,28 @@ public sealed class Parser
     {
         var startIndex = _tokenIndex;
 
-        if (CurrentToken is SymbolToken symbol)
+        if (TryExpectSymbol(out var symbol))
         {
-            switch (symbol.Symbol)
+            switch (symbol)
             {
                 case Symbol.OpenBrace:
-                    return ParseBlock();
+                    return ParseBlock(startIndex);
                 case Symbol.Return:
-                    return ParseReturn();
+                    return ParseReturn(startIndex);
                 case Symbol.If:
-                    return ParseIf();
+                    return ParseIf(startIndex);
                 case Symbol.While:
-                    return ParseWhile();
+                    return ParseWhile(startIndex);
                 case Symbol.For:
-                    return ParseFor();
+                    return ParseFor(startIndex);
                 case Symbol.Let:
-                    return ParseVariableDeclaration();
+                    return ParseVariableDeclaration(startIndex);
                 case Symbol.Defer:
-                    return ParseDefer();
+                    return ParseDefer(startIndex);
                 case Symbol.Break:
-                    return ParseBreak();
+                    return new BreakSyntax(GetTokens(startIndex));
                 case Symbol.Continue:
-                    return ParseContinue();
+                    return new ContinueSyntax(GetTokens(startIndex));
             }
         }
 
@@ -249,10 +250,8 @@ public sealed class Parser
         return new StatementExpressionSyntax(GetTokens(startIndex), expr);
     }
 
-    private VariableDeclarationSyntax ParseVariableDeclaration()
+    private VariableDeclarationSyntax ParseVariableDeclaration(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.Let);
         var name = ExpectIdentifier().Value;
 
         var explicitType = Optional<TypeSyntax>.Empty();
@@ -270,33 +269,14 @@ public sealed class Parser
         return new VariableDeclarationSyntax(GetTokens(startIndex), name, explicitType, assignment);
     }
 
-    private DeferSyntax ParseDefer()
+    private DeferSyntax ParseDefer(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.Defer);
         var statement = ParseStatement();
         return new DeferSyntax(GetTokens(startIndex), statement);
     }
 
-    private BreakSyntax ParseBreak()
+    private ReturnSyntax ParseReturn(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.Break);
-        return new BreakSyntax(GetTokens(startIndex));
-    }
-
-    private ContinueSyntax ParseContinue()
-    {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.Continue);
-        return new ContinueSyntax(GetTokens(startIndex));
-    }
-
-    private ReturnSyntax ParseReturn()
-    {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.Return);
-
         var value = Optional<ExpressionSyntax>.Empty();
 
         if (!TryExpectSymbol(Symbol.Semi))
@@ -307,42 +287,38 @@ public sealed class Parser
         return new ReturnSyntax(GetTokens(startIndex), value);
     }
 
-    private IfSyntax ParseIf()
+    private IfSyntax ParseIf(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.If);
         var condition = ParseExpression();
         var body = ParseBlock();
 
         var elseStatement = Optional<Variant<IfSyntax, BlockSyntax>>.Empty();
+
+        var elseStartIndex = _tokenIndex;
         if (TryExpectSymbol(Symbol.Else))
         {
-            if (CurrentToken is SymbolToken { Symbol: Symbol.If })
+            if (TryExpectSymbol(Symbol.If))
             {
-                elseStatement = (Variant<IfSyntax, BlockSyntax>)ParseIf();
+                elseStatement = (Variant<IfSyntax, BlockSyntax>)ParseIf(elseStartIndex);
             }
             else
             {
-                elseStatement = (Variant<IfSyntax, BlockSyntax>)ParseBlock();
+                elseStatement = (Variant<IfSyntax, BlockSyntax>)ParseBlock(elseStartIndex);
             }
         }
 
         return new IfSyntax(GetTokens(startIndex), condition, body, elseStatement);
     }
 
-    private WhileSyntax ParseWhile()
+    private WhileSyntax ParseWhile(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.While);
         var condition = ParseExpression();
         var body = ParseBlock();
         return new WhileSyntax(GetTokens(startIndex), condition, body);
     }
 
-    private ForSyntax ParseFor()
+    private ForSyntax ParseFor(int startIndex)
     {
-        var startIndex = _tokenIndex;
-        ExpectSymbol(Symbol.For);
         var elementIdent = ExpectIdentifier().Value;
 
         string? indexIndent = null;
@@ -633,8 +609,14 @@ public sealed class Parser
     private BlockSyntax ParseBlock()
     {
         var startIndex = _tokenIndex;
-        List<StatementSyntax> statements = [];
         ExpectSymbol(Symbol.OpenBrace);
+        return ParseBlock(startIndex);
+    }
+    
+    private BlockSyntax ParseBlock(int startIndex)
+    {
+        List<StatementSyntax> statements = [];
+
         while (!TryExpectSymbol(Symbol.CloseBrace))
         {
             try
@@ -814,6 +796,19 @@ public sealed class Parser
         }
     }
 
+    private bool TryExpectSymbol(out Symbol symbol)
+    {
+        if (CurrentToken is SymbolToken symbolToken)
+        {
+            Next();
+            symbol = symbolToken.Symbol;
+            return true;
+        }
+
+        symbol = default;
+        return false;
+    }
+
     private bool TryExpectSymbol(Symbol symbol)
     {
         if (CurrentToken is SymbolToken symbolToken && symbolToken.Symbol == symbol)