Fixed return value

src/Compiler/ModuleBuilder.cpp

@@ -6,6 +6,7 @@
 #include "Parser/Expression/ExpressionCall.h"
 #include "Parser/Expression/ExpressionIfElse.h"
 #include "Parser/Expression/ExpressionBinary.h"
+#include "Parser/Expression/ExpressionBlock.h"
 
 #include "Parser/Statement/StatementFunction.h"
 #include "Parser/Statement/StatementVariable.h"
@@ -278,9 +279,8 @@ llvm::Value *ModuleBuilder::valueForIfElse(shared_ptr<ExpressionIfElse> expressi
 
     // Then
     builder->SetInsertPoint(thenBlock);
-    //llvm::Value *thenValue = valueForExpression(expression->getThenBlock()->getStatementExpression()->getExpression());
+    llvm::Value *thenValue = valueForExpression(expression->getThenBlock()->getResultStatementExpression()->getExpression());
-    llvm::Value *thenValue = llvm::UndefValue::get(typeVoid);
+    buildStatement(expression->getThenBlock()->getStatementBlock());
-    //buildStatement(expression->getThenBlock());
     builder->CreateBr(mergeBlock);
     thenBlock = builder->GetInsertBlock();
 
@@ -290,9 +290,8 @@ llvm::Value *ModuleBuilder::valueForIfElse(shared_ptr<ExpressionIfElse> expressi
     llvm::Value *elseValue = nullptr;
     if (expression->getElseBlock() != nullptr) {
         valuesCount++;
-        //elseValue = valueForExpression(expression->getElseBlock()->getStatementExpression()->getExpression());
+        elseValue = valueForExpression(expression->getElseBlock()->getResultStatementExpression()->getExpression());
-        llvm::Value *elseValue = llvm::UndefValue::get(typeVoid);
+        buildStatement(expression->getElseBlock()->getStatementBlock());
-        //buildStatement(expression->getElseBlock());
     }
     builder->CreateBr(mergeBlock);
     elseBlock = builder->GetInsertBlock();

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());
+        resultStatementExpression = dynamic_pointer_cast<StatementExpression>(statements.back());
-        this->statements.pop_back();
+        valueType = resultStatementExpression->getExpression()->getValueType();
-        valueType = resultExpression->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<StatementBlock> statementBlock;
-    shared_ptr<StatementExpression> resultExpression;
+    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();