Fixed return value

src/Parser/Expression/ExpressionBlock.cpp

@@ -2,16 +2,26 @@
 
 #include "Parser/Expression/ExpressionLiteral.h"
 #include "Parser/Statement/StatementExpression.h"
+#include "Parser/Statement/StatementBlock.h"
 
 ExpressionBlock::ExpressionBlock(vector<shared_ptr<Statement>> statements):
-Expression(ExpressionKind::BLOCK, ValueType::NONE), statements(statements) {
+Expression(ExpressionKind::BLOCK, ValueType::NONE) {
     if (!statements.empty() && statements.back()->getKind() == StatementKind::EXPRESSION) {
-        resultExpression = dynamic_pointer_cast<StatementExpression>(statements.back());
-        this->statements.pop_back();
-        valueType = resultExpression->getExpression()->getValueType();
+        resultStatementExpression = dynamic_pointer_cast<StatementExpression>(statements.back());
+        valueType = resultStatementExpression->getExpression()->getValueType();
+        statements.pop_back();
     } else {
-        resultExpression = make_shared<StatementExpression>(ExpressionLiteral::none);
+        resultStatementExpression = make_shared<StatementExpression>(ExpressionLiteral::NONE);
     }
+    statementBlock = make_shared<StatementBlock>(statements);
+}
+
+shared_ptr<StatementBlock> ExpressionBlock::getStatementBlock() {
+    return statementBlock;
+}
+
+shared_ptr<StatementExpression> ExpressionBlock::getResultStatementExpression() {
+    return resultStatementExpression;
 }
 
 string ExpressionBlock::toString(int indent) {

src/Parser/Expression/ExpressionBlock.h

@@ -1,14 +1,17 @@
 #include "Parser/Expression/Expression.h"
 
 class Statement;
+class StatementBlock;
 class StatementExpression;
 
 class ExpressionBlock: public Expression {
 private:
-    vector<shared_ptr<Statement>> statements;
-    shared_ptr<StatementExpression> resultExpression;
+    shared_ptr<StatementBlock> statementBlock;
+    shared_ptr<StatementExpression> resultStatementExpression;
 
 public:
     ExpressionBlock(vector<shared_ptr<Statement>> statements);
+    shared_ptr<StatementBlock> getStatementBlock();
+    shared_ptr<StatementExpression> getResultStatementExpression();
     string toString(int indent) override;
 };

src/Parser/Expression/ExpressionIfElse.cpp

@@ -3,7 +3,11 @@
 #include "Parser/Expression/ExpressionBlock.h"
 
 ExpressionIfElse::ExpressionIfElse(shared_ptr<Expression> condition, shared_ptr<ExpressionBlock> thenBlock, shared_ptr<ExpressionBlock> elseBlock):
-Expression(ExpressionKind::IF_ELSE, ValueType::NONE), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) { }
+Expression(ExpressionKind::IF_ELSE, ValueType::NONE), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
+    // Figure out resulting type
+    if (elseBlock == nullptr || thenBlock->getValueType() == elseBlock->getValueType())
+        valueType = thenBlock->getValueType();
+}
 
 shared_ptr<Expression> ExpressionIfElse::getCondition() {
     return condition;

src/Parser/Expression/ExpressionLiteral.cpp

@@ -1,6 +1,6 @@
 #include "ExpressionLiteral.h"
 
-shared_ptr<ExpressionLiteral> ExpressionLiteral::none;
+shared_ptr<ExpressionLiteral> ExpressionLiteral::NONE;
 
 ExpressionLiteral::ExpressionLiteral():
 Expression(ExpressionKind::LITERAL, ValueType::NONE) { }

src/Parser/Expression/ExpressionLiteral.h

@@ -9,7 +9,7 @@ private:
     ExpressionLiteral();
 
 public:
-    static shared_ptr<ExpressionLiteral> none;
+    static shared_ptr<ExpressionLiteral> NONE;
 
     ExpressionLiteral(shared_ptr<Token> token);
     bool getBoolValue();