3 files changed, 95 insertions, 44 deletions

diff --git a/orang/src/main/java/lv/enes/orang/Parser.java b/parser/src/main/java/lv/enes/orang/parser/Parser.java
index 77abe24..6c86e85 100644
--- a/orang/src/main/java/lv/enes/orang/Parser.java
+++ b/parser/src/main/java/lv/enes/orang/parser/Parser.java
@@ -1,9 +1,12 @@
-package lv.enes.orang;
+package lv.enes.orang.parser;
 
 import lv.enes.orang.ast.*;
 import lv.enes.orang.ast.IfElseExpression;
 import lv.enes.orang.ast.Statement;
+import lv.enes.orang.lexer.Lexer;
+import lv.enes.orang.lexer.Token;
 import lv.enes.orang.utils.NonEmptyList;
+import lv.enes.orang.utils.PeekableStream;
 
 import java.io.InputStream;
 import java.io.Reader;
@@ -49,13 +52,53 @@ public class Parser {
 
         public Program parseProgram() throws ParserException {
                 var statements = new ArrayList<Statement>();
-                while (!maybeConsumeToken(TokenType.EOF)) {
+                while (!maybeConsumeToken(Token.Type.EOF)) {
                         statements.add(parseStatement());
-                        maybeConsumeToken(TokenType.SEMICOLON);
+                        maybeConsumeToken(Token.Type.SEMICOLON);
                 }
                 return new Program(Collections.unmodifiableList(statements));
         }
 
+        private static boolean isBinaryOp(Token token) {
+                return switch (token.type()) {
+                        case ASTERISK, SLASH, PLUS, MINUS, QUESTION_EQUAL, SLASH_EQUAL, GREATER, GREATER_EQUAL, LESS, LESS_EQUAL
+                                        -> true;
+                        default -> false;
+                };
+        }
+
+        private static BinaryExpression.Operator toBinaryOp(Token token) {
+                return switch (token.type()) {
+                        case ASTERISK -> BinaryExpression.Operator.MULTIPLY;
+                        case SLASH -> BinaryExpression.Operator.DIVIDE;
+                        case PLUS -> BinaryExpression.Operator.ADD;
+                        case MINUS -> BinaryExpression.Operator.SUBTRACT;
+                        case QUESTION_EQUAL -> BinaryExpression.Operator.EQUALS;
+                        case SLASH_EQUAL -> BinaryExpression.Operator.NOT_EQUALS;
+                        case GREATER -> BinaryExpression.Operator.GT;
+                        case GREATER_EQUAL -> BinaryExpression.Operator.GTE;
+                        case LESS -> BinaryExpression.Operator.LT;
+                        case LESS_EQUAL -> BinaryExpression.Operator.LTE;
+                        default -> throw new IllegalStateException(STR."Token \{token.type()} is not a binary operator");
+                };
+        }
+
+        public static boolean isUnaryOp(Token token) {
+                return switch (token.type()) {
+                        case PLUS, MINUS, BANG -> true;
+                        default -> false;
+                };
+        }
+
+        public static UnaryExpression.Operator toUnaryOp(Token token) {
+                return switch (token.type()) {
+                        case PLUS -> UnaryExpression.Operator.PLUS;
+                        case MINUS -> UnaryExpression.Operator.NEGATE;
+                        case BANG -> UnaryExpression.Operator.NOT;
+                        default -> throw new IllegalStateException(STR."Token \{token.type()} is not a unary operator");
+                };
+        }
+
         private Token consume(Predicate<Token> pred, String msg) throws ParserException {
                 var tok = input.next();
                 if (!pred.test(tok)) {
@@ -64,11 +107,11 @@ public class Parser {
                 return tok;
         }
 
-        private Token consumeToken(TokenType type) throws ParserException {
+        private Token consumeToken(Token.Type type) throws ParserException {
                 return consume(tok -> tok.type() == type, STR."Expected \{type}");
         }
 
-        private boolean maybeConsumeToken(TokenType type) {
+        private boolean maybeConsumeToken(Token.Type type) {
                 if (input.peek().type() == type) {
                         input.next();
                         return true;
@@ -77,16 +120,16 @@ public class Parser {
         }
 
         private ArrayExpression parseArray() throws ParserException {
-                consumeToken(TokenType.BRACKET_LEFT);
-                if (maybeConsumeToken(TokenType.BRACKET_RIGHT)) {
+                consumeToken(Token.Type.BRACKET_LEFT);
+                if (maybeConsumeToken(Token.Type.BRACKET_RIGHT)) {
                         return new ArrayExpression(List.of());
                 }
 
                 var items = new ArrayList<Expression>();
                 do {
                         items.add(parseExpression());
-                } while (maybeConsumeToken(TokenType.COMMA));
-                consumeToken(TokenType.BRACKET_RIGHT);
+                } while (maybeConsumeToken(Token.Type.COMMA));
+                consumeToken(Token.Type.BRACKET_RIGHT);
 
                 return new ArrayExpression(Collections.unmodifiableList(items));
         }
@@ -94,11 +137,11 @@ public class Parser {
         private List<ArgSpec> parseArgSpecs() throws ParserException {
                 var argSpecs = new ArrayList<ArgSpec>();
                 while (true) {
-                        if (input.peek().type() == TokenType.IDENTIFIER) {
+                        if (input.peek().type() == Token.Type.IDENTIFIER) {
                                 argSpecs.add(ArgSpec.named(input.next().literal()));
-                        } else if (input.peek().type() == TokenType.PAREN_LEFT) {
-                                consumeToken(TokenType.PAREN_LEFT);
-                                consumeToken(TokenType.PAREN_RIGHT);
+                        } else if (input.peek().type() == Token.Type.PAREN_LEFT) {
+                                consumeToken(Token.Type.PAREN_LEFT);
+                                consumeToken(Token.Type.PAREN_RIGHT);
                                 argSpecs.add(ArgSpec.nothing());
                         } else {
                                 break;
@@ -109,20 +152,20 @@ public class Parser {
 
         private Expression parseBinaryExpression() throws ParserException {
                 var lhs = parseCallExpression();
-                if (!input.peek().type().isBinaryOp()) {
+                if (!isBinaryOp(input.peek())) {
                         return lhs;
                 }
 
-                return parseBinaryExpressionRhs(lhs, input.next().type().toBinaryOp());
+                return parseBinaryExpressionRhs(lhs, toBinaryOp(input.next()));
         }
 
         private Expression parseBinaryExpressionRhs(Expression lhs, BinaryExpression.Operator op) throws ParserException {
                 var rhs = parseCallExpression();
-                if (!input.peek().type().isBinaryOp()) {
+                if (!isBinaryOp(input.peek())) {
                         return new BinaryExpression(op, lhs, rhs);
                 }
 
-                var op2 = input.next().type().toBinaryOp();
+                var op2 = toBinaryOp(input.next());
                 if (op2.bindsStrongerThan(op)) {
                         return new BinaryExpression(op, lhs, parseBinaryExpressionRhs(rhs, op2));
                 } else {
@@ -131,8 +174,8 @@ public class Parser {
         }
 
         private BooleanLiteral parseBoolean() throws ParserException {
-                var t = consume(tok -> tok.type() == TokenType.FALSE || tok.type() == TokenType.TRUE, "Expected TRUE or FALSE");
-                return new BooleanLiteral(t.type() == TokenType.TRUE);
+                var t = consume(tok -> tok.type() == Token.Type.FALSE || tok.type() == Token.Type.TRUE, "Expected TRUE or FALSE");
+                return new BooleanLiteral(t.type() == Token.Type.TRUE);
         }
 
         private Expression parseCallExpression() throws ParserException {
@@ -145,9 +188,9 @@ public class Parser {
         }
 
         private Definition parseDefinition() throws ParserException {
-                consumeToken(TokenType.DEF);
+                consumeToken(Token.Type.DEF);
                 var defSpec = parseDefSpec();
-                consumeToken(TokenType.EQUAL);
+                consumeToken(Token.Type.EQUAL);
                 var value = parseExpression();
                 if (defSpec.args().isEmpty()) {
                         return new Definition(defSpec.name(), value);
@@ -157,59 +200,59 @@ public class Parser {
         }
 
         private DefSpec parseDefSpec() throws ParserException {
-                var name = consumeToken(TokenType.IDENTIFIER).literal();
+                var name = consumeToken(Token.Type.IDENTIFIER).literal();
                 var argSpecs = parseArgSpecs();
                 return new DefSpec(name, argSpecs);
         }
 
         private DoExpression parseDoExpression() throws ParserException {
-                consumeToken(TokenType.DO);
+                consumeToken(Token.Type.DO);
                 var exprs = new ArrayList<Expression>();
                 do {
                         exprs.add(parseExpression());
-                } while (maybeConsumeToken(TokenType.SEMICOLON));
-                consumeToken(TokenType.END);
+                } while (maybeConsumeToken(Token.Type.SEMICOLON));
+                consumeToken(Token.Type.END);
                 return new DoExpression(Collections.unmodifiableList(exprs));
         }
 
         private Expression parseExpression() throws ParserException {
-                if (input.peek().type().isUnaryOp()) {
+                if (isUnaryOp(input.peek())) {
                         return parseUnaryExpression();
                 }
                 return parseBinaryExpression();
         }
 
         private FnExpression parseFnExpression() throws ParserException {
-                consumeToken(TokenType.FN);
+                consumeToken(Token.Type.FN);
                 var argSpecs = parseArgSpecs();
                 if (argSpecs.isEmpty()) {
                         throw new ParserException("Function definition with no arguments");
                 }
-                var body = maybeConsumeToken(TokenType.MINUS_GREATER) ? parseExpression() : parseDoExpression();
+                var body = maybeConsumeToken(Token.Type.MINUS_GREATER) ? parseExpression() : parseDoExpression();
                 return new FnExpression(new NonEmptyList<>(argSpecs), body);
         }
 
         private IfElseExpression parseIfElseExpression() throws ParserException {
-                consumeToken(TokenType.IF);
+                consumeToken(Token.Type.IF);
                 var cond = parseExpression();
-                consumeToken(TokenType.THEN);
+                consumeToken(Token.Type.THEN);
                 var trueBranch = parseExpression();
-                consumeToken(TokenType.ELSE);
+                consumeToken(Token.Type.ELSE);
                 var falseBranch = parseExpression();
                 return new IfElseExpression(cond, trueBranch, falseBranch);
         }
 
         private IntLiteral parseInteger() throws ParserException {
-                var tok = consumeToken(TokenType.INTEGER);
+                var tok = consumeToken(Token.Type.INTEGER);
                 return new IntLiteral(Integer.parseInt(tok.literal()));
         }
 
         private LetInExpression parseLetInExpression() throws ParserException {
-                consumeToken(TokenType.LET);
+                consumeToken(Token.Type.LET);
                 var bindings = new ArrayList<LetInExpression.Binding>();
                 do {
                         var defSpec = parseDefSpec();
-                        consumeToken(TokenType.EQUAL);
+                        consumeToken(Token.Type.EQUAL);
                         var value = parseExpression();
                         if (defSpec.args().isEmpty()) {
                                 bindings.add(new LetInExpression.Binding(defSpec.name(), value));
@@ -217,8 +260,8 @@ public class Parser {
                                 var fn = new FnExpression(new NonEmptyList<>(defSpec.args()), value);
                                 bindings.add(new LetInExpression.Binding(defSpec.name(), fn));
                         }
-                } while (maybeConsumeToken(TokenType.AND));
-                consumeToken(TokenType.IN);
+                } while (maybeConsumeToken(Token.Type.AND));
+                consumeToken(Token.Type.IN);
                 var body = parseExpression();
                 return new LetInExpression(Collections.unmodifiableList(bindings), body);
         }
@@ -226,12 +269,12 @@ public class Parser {
         private Expression parseSimpleExpression() throws ParserException {
                 return switch (input.peek().type()) {
                         case PAREN_LEFT -> {
-                                consumeToken(TokenType.PAREN_LEFT);
-                                if (maybeConsumeToken(TokenType.PAREN_RIGHT)) {
+                                consumeToken(Token.Type.PAREN_LEFT);
+                                if (maybeConsumeToken(Token.Type.PAREN_RIGHT)) {
                                         yield VoidExpression.INSTANCE;
                                 }
                                 var expr = parseExpression();
-                                consumeToken(TokenType.PAREN_RIGHT);
+                                consumeToken(Token.Type.PAREN_RIGHT);
                                 yield expr;
                         }
                         case TRUE, FALSE -> parseBoolean();
@@ -247,7 +290,7 @@ public class Parser {
                 };
         }
 
-        private boolean couldStartSimpleExpression(TokenType type) {
+        private boolean couldStartSimpleExpression(Token.Type type) {
                 return switch (type) {
                         case PAREN_LEFT, TRUE, FALSE, INTEGER, IDENTIFIER, STRING, BRACKET_LEFT, IF, LET, FN, DO -> true;
                         default -> false;
@@ -255,7 +298,7 @@ public class Parser {
         }
 
         private Statement parseStatement() throws ParserException {
-                if (input.peek().type() == TokenType.DEF) {
+                if (input.peek().type() == Token.Type.DEF) {
                         return parseDefinition();
                 } else {
                         return new ExpressionStatement(parseExpression());
@@ -286,8 +329,8 @@ public class Parser {
         }
 
         private Expression parseUnaryExpression() throws ParserException {
-                if (input.peek().type().isUnaryOp()) {
-                        var op = input.next().type().toUnaryOp();
+                if (isUnaryOp(input.peek())) {
+                        var op = toUnaryOp(input.next());
                         return new UnaryExpression(op, parseUnaryExpression());
                 } else {
                         return parseSimpleExpression();
diff --git a/orang/src/main/java/lv/enes/orang/ParserException.java b/parser/src/main/java/lv/enes/orang/parser/ParserException.java
index bd65e7a..632ce15 100644
--- a/orang/src/main/java/lv/enes/orang/ParserException.java
+++ b/parser/src/main/java/lv/enes/orang/parser/ParserException.java
@@ -1,4 +1,4 @@
-package lv.enes.orang;
+package lv.enes.orang.parser;
 
 import lv.enes.orang.core.OrangException;
 
diff --git a/parser/src/main/java/module-info.java b/parser/src/main/java/module-info.java
new file mode 100644
index 0000000..43c2dc5
--- /dev/null
+++ b/parser/src/main/java/module-info.java
@@ -0,0 +1,8 @@
+module lv.enes.orang.parser {
+        exports lv.enes.orang.parser;
+
+        requires lv.enes.orang.ast;
+        requires lv.enes.orang.core;
+        requires lv.enes.orang.lexer;
+        requires lv.enes.orang.utils;
+}
\ No newline at end of file