diff --git a/src/Expression.cpp b/src/Expression.cpp
index 4eadd62..9b309dc 100644
--- a/src/Expression.cpp
+++ b/src/Expression.cpp
@@ -1,52 +1,26 @@
 #include "Expression.h"
 
-Expression::Expression(Kind kind, Token token, shared_ptr<Expression> left, shared_ptr<Expression> right): token(token) {
-    switch (kind) {
-        case LITERAL:
-            setupLiteral(token);
-            break;
-        case GROUPING:
-            setupGrouping(token, left);
-            break;
-        case BINARY:
-            setupBinary(token, left, right);
-            break;
-        case INVALID:
-            break;
-    }
+Expression::Expression(Kind kind):
+    kind(kind) {
 }
 
-void Expression::setupLiteral(Token token) {
-    bool isKindValid = token.isOfKind({Token::Kind::INTEGER});
-    if (!isKindValid)
-        return;
-
-    kind = LITERAL;
-    integer = stoi(token.getLexme());
+Expression::Kind Expression::getKind() {
+    return kind;
 }
 
-void Expression::setupGrouping(Token token, shared_ptr<Expression> expression) {
-    bool isKindValid = token.getKind() == Token::Kind::LEFT_PAREN;
-    bool isExpressionValid = expression != nullptr && expression->getKind() != Kind::INVALID;
-
-    if (!isKindValid || !isExpressionValid)
-        return;
-    
-    kind = GROUPING;
-    left = expression;
+bool Expression::isValid() {
+    return kind != Expression::Kind::INVALID;
 }
 
-void Expression::setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right) {
-    bool isKindValid = token.isOfKind({Token::Kind::PLUS, Token::Kind::MINUS, Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT});
-    bool isLeftValid = left != nullptr && left->getKind() != Kind::INVALID;
-    bool isRightValid = right != nullptr && right->getKind() != Kind::INVALID;
+string Expression::toString() {
+    return "EXPRESSION";
+}
 
-    if (!isKindValid || !isLeftValid || !isRightValid)
-        return;
-
-    kind = BINARY;
-
-    switch (token.getKind()) {
+//
+// ExpressionBinary
+ExpressionBinary::ExpressionBinary(shared_ptr<Token> token, shared_ptr<Expression> left, shared_ptr<Expression> right):
+    Expression(Expression::Kind::BINARY), left(left), right(right) {
+    switch (token->getKind()) {
         case Token::Kind::PLUS:
             operation = ADD;
             break;
@@ -62,66 +36,77 @@ void Expression::setupBinary(Token token, shared_ptr<Expression> left, shared_pt
         case Token::Kind::PERCENT:
             operation = MOD;
             break;
-        case Token::Kind::INVALID:
-            break;
         default:
             exit(1);
     }
-
-    this->left = left;
-    this->right = right;
 }
 
-Expression::Kind Expression::getKind() {
-    return kind;
-}
-
-Token Expression::getToken() {
-    return token;
-}
-
-int64_t Expression::getInteger() {
-    return integer;
-}
-
-Expression::Operator Expression::getOperator() {
+ExpressionBinary::Operation ExpressionBinary::getOperation() {
     return operation;
 }
 
-shared_ptr<Expression> Expression::getLeft() {
+shared_ptr<Expression> ExpressionBinary::getLeft() {
     return left;
 }
 
-shared_ptr<Expression> Expression::getRight() {
+shared_ptr<Expression> ExpressionBinary::getRight() {
     return right;
 }
 
-bool Expression::isValid() {
-    return kind != Expression::Kind::INVALID;
+string ExpressionBinary::toString() {
+    switch (operation) {
+    case ADD:
+        return "<+ " + left->toString() + " " + right->toString() + ">";
+    case SUB:
+        return "<- " + left->toString() + " " + right->toString() + ">";
+    case MUL:
+        return "<* " + left->toString() + " " + right->toString() + ">";
+    case DIV:
+        return "</ " + left->toString() + " " + right->toString() + ">";
+    case MOD:
+        return "<% " + left->toString() + " " + right->toString() + ">";
+    }
 }
 
-string Expression::toString() {
-    switch (kind) {
-        case LITERAL:
-            return to_string(integer);
-        case GROUPING:
-            return "<( " + left->toString() + " )>";
-        case BINARY:
-            switch (operation) {
-                case ADD:
-                    return "<+ " + left->toString() + " " + right->toString() + ">";
-                case SUB:
-                    return "<- " + left->toString() + " " + right->toString() + ">";
-                case MUL:
-                    return "<* " + left->toString() + " " + right->toString() + ">";
-                case DIV:
-                    return "</ " + left->toString() + " " + right->toString() + ">";
-                case MOD:
-                    return "<% " + left->toString() + " " + right->toString() + ">";
-                case NONE:
-                    return "NONE";
-            }
-        case INVALID:
-            return "INVALID";
-    }
+//
+// ExpressionLiteral
+ExpressionLiteral::ExpressionLiteral(shared_ptr<Token> token):
+    Expression(Expression::Kind::LITERAL) {
+    integer = stoi(token->getLexme());
+}
+
+int64_t ExpressionLiteral::getInteger() {
+    return integer;
+}
+
+string ExpressionLiteral::toString() {
+    return to_string(integer);
+}
+
+//
+// ExpressionGrouping
+ExpressionGrouping::ExpressionGrouping(shared_ptr<Expression> expression):
+    Expression(Expression::Kind::GROUPING), expression(expression) {
+}
+
+shared_ptr<Expression> ExpressionGrouping::getExpression() {
+    return expression;
+}
+
+string ExpressionGrouping::toString() {
+    return "<( " + expression->toString() + " )>";
+}
+
+//
+// ExpressionInvalid
+ExpressionInvalid::ExpressionInvalid(shared_ptr<Token> token):
+    Expression(Expression::Kind::INVALID), token(token) {
+}
+
+shared_ptr<Token> ExpressionInvalid::getToken() {
+    return token;
+}
+
+string ExpressionInvalid::toString() {
+    return "Invalid token " + token->toString() + " at " + to_string(token->getLine()) + ":" + to_string(token->getColumn()) + "\n";
 }
\ No newline at end of file
diff --git a/src/Expression.h b/src/Expression.h
index cde03aa..e4547bc 100644
--- a/src/Expression.h
+++ b/src/Expression.h
@@ -14,37 +14,67 @@ public:
         INVALID
     };
 
-    enum Operator {
+private:
+    Kind kind;
+
+public:
+    Expression(Kind kind);
+    Kind getKind();
+    bool isValid();
+    virtual string toString();
+};
+
+class ExpressionBinary: public Expression {
+public:
+    enum Operation {
         ADD,
         SUB,
         MUL,
         DIV,
-        MOD,
-        NONE
+        MOD
     };
 
 private:
-    Kind kind = INVALID;
-    Token token;
-    int64_t integer = 0;
-    Operator operation = NONE;
-    shared_ptr<Expression> left = nullptr;
-    shared_ptr<Expression> right = nullptr;
-
-    void setupLiteral(Token token);
-    void setupGrouping(Token token, shared_ptr<Expression> expression);
-    void setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right);
+    Operation operation;
+    shared_ptr<Expression> left;
+    shared_ptr<Expression> right;
 
 public:
-    Expression(Kind kind, Token token, shared_ptr<Expression> left, shared_ptr<Expression> right);
-    Kind getKind();
-    Token getToken();
-    int64_t getInteger();
-    Operator getOperator();
+    ExpressionBinary(shared_ptr<Token> token, shared_ptr<Expression> left, shared_ptr<Expression> right);
+    Operation getOperation();
     shared_ptr<Expression> getLeft();
     shared_ptr<Expression> getRight();
-    bool isValid();
-    string toString();
+    string toString() override;
+};
+
+class ExpressionLiteral: public Expression {
+private:
+    int64_t integer = 0;
+
+public:
+    ExpressionLiteral(shared_ptr<Token> token);
+    int64_t getInteger();
+    string toString() override;
+};
+
+class ExpressionGrouping: public Expression {
+private:
+    shared_ptr<Expression> expression;
+
+public:
+    ExpressionGrouping(shared_ptr<Expression> expression);
+    shared_ptr<Expression> getExpression();
+    string toString() override;
+};
+
+class ExpressionInvalid: public Expression {
+private:
+    shared_ptr<Token> token;
+
+public:
+    ExpressionInvalid(shared_ptr<Token> token);
+    shared_ptr<Token> getToken();
+    string toString() override;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/Parser.cpp b/src/Parser.cpp
index 8cf23f0..600d848 100644
--- a/src/Parser.cpp
+++ b/src/Parser.cpp
@@ -123,7 +123,7 @@ shared_ptr<StatementInvalid> Parser::matchStatementInvalid() {
 // Expression
 //
 shared_ptr<Expression> Parser::nextExpression() {
-    return nullptr;
+    return matchExpressionInvalid();
 }
 
 /*shared_ptr<Expression> Parser::term() {
@@ -207,6 +207,10 @@ shared_ptr<Expression> Parser::matchBinary(shared_ptr<Expression> left) {
     return make_shared<Expression>(Expression::Kind::INVALID, token, nullptr, nullptr);
 }*/
 
+shared_ptr<ExpressionInvalid> Parser::matchExpressionInvalid() {
+    return make_shared<ExpressionInvalid>(tokens.at(currentIndex));
+}
+
 bool Parser::matchesTokenKinds(vector<Token::Kind> kinds) {
     if (currentIndex + kinds.size() >= tokens.size())
         return false;
diff --git a/src/Parser.h b/src/Parser.h
index 6749622..3675d09 100644
--- a/src/Parser.h
+++ b/src/Parser.h
@@ -29,6 +29,7 @@ private:
     shared_ptr<Expression> matchInteger();
     shared_ptr<Expression> matchGrouping();
     shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);*/
+    shared_ptr<ExpressionInvalid> matchExpressionInvalid();
 
     bool matchesTokenKinds(vector<Token::Kind> kinds);