Unary Arithmetic (#34)

* test ci thing * test ci thing * revert ci * add unary ops
jackparsonss · Jun 26, 2024 · 14cc99a · 14cc99a
1 parent a29e174
commit 14cc99a
Show file tree

Hide file tree

Showing 14 changed files with 123 additions and 13 deletions.
diff --git a/grammar/Fusion.g4 b/grammar/Fusion.g4
@@ -26,6 +26,7 @@ return: RETURN expr SEMI;
 
 expr
     : call                                               #callExpr
+    | (op=MINUS | op=BANG) expr                          #unary
     | <assoc='right'> expr CARET expr                    #power
     | expr (op=STAR | op=SLASH | op=MOD | op=DSTAR) expr #mulDivMod
     | expr (op=PLUS | op=MINUS) expr                     #addSub
@@ -76,6 +77,7 @@ EQ: '==';
 CARET: '^';
 DAND: '&&';
 DOR: '||';
+BANG: '!';
 
 // comments
 LINE_COMMENT: '//' .*? ('\n' | EOF) -> skip;

diff --git a/include/ast/ast.h b/include/ast/ast.h
@@ -32,9 +32,15 @@ enum class BinaryOpType {
     OR,
 };
 
+enum class UnaryOpType {
+    MINUS,
+    NOT,
+};
+
 std::string random_name();
 std::string qualifier_to_string(Qualifier qualifier);
 std::string binary_op_type_to_string(BinaryOpType type);
+std::string unary_op_type_to_string(UnaryOpType type);
 
 class Node {
    public:
@@ -202,4 +208,13 @@ class BinaryOperator : public Expression {
                    Token* token);
     void xml(int level) override;
 };
+
+class UnaryOperator : public Expression {
+   public:
+    UnaryOpType type;
+    shared_ptr<Expression> rhs;
+
+    UnaryOperator(UnaryOpType type, shared_ptr<Expression> rhs, Token* token);
+    void xml(int level) override;
+};
 }  // namespace ast
diff --git a/include/ast/builder.h b/include/ast/builder.h
@@ -43,4 +43,5 @@ class Builder : public FusionBaseVisitor {
     std::any visitGtLtCond(FusionParser::GtLtCondContext* ctx) override;
     std::any visitEqNeCond(FusionParser::EqNeCondContext* ctx) override;
     std::any visitAndOrCond(FusionParser::AndOrCondContext* ctx) override;
+    std::any visitUnary(FusionParser::UnaryContext* ctx) override;
 };
diff --git a/include/ast/passes/pass.h b/include/ast/passes/pass.h
@@ -27,6 +27,7 @@ class Pass {
     virtual void visit_parameter(shared_ptr<ast::Parameter>);
     virtual void visit_return(shared_ptr<ast::Return>);
     virtual void visit_binary_operator(shared_ptr<ast::BinaryOperator>);
+    virtual void visit_unary_operator(shared_ptr<ast::UnaryOperator>);
 };
 
 namespace pass {

diff --git a/include/backend/backend.h b/include/backend/backend.h
@@ -35,4 +35,5 @@ class Backend {
     mlir::Value visit_parameter(shared_ptr<ast::Parameter>);
     mlir::Value visit_return(shared_ptr<ast::Return>);
     mlir::Value visit_binary_operator(shared_ptr<ast::BinaryOperator>);
+    mlir::Value visit_unary_operator(shared_ptr<ast::UnaryOperator>);
 };
diff --git a/include/backend/expressions/arithmetic.h b/include/backend/expressions/arithmetic.h
@@ -23,6 +23,9 @@ mlir::Value lte(mlir::Value lhs, mlir::Value rhs, TypePtr type);
 mlir::Value and_(mlir::Value lhs, mlir::Value rhs, TypePtr type);
 mlir::Value or_(mlir::Value lhs, mlir::Value rhs, TypePtr type);
 
+mlir::Value not_(mlir::Value value);
+mlir::Value negate(mlir::Value value, TypePtr type);
+
 mlir::Value binary_equality(mlir::Value lhs,
                             mlir::Value rhs,
                             TypePtr type,
@@ -31,4 +34,7 @@ mlir::Value binary_operation(mlir::Value lhs,
                              mlir::Value rhs,
                              ast::BinaryOpType op_type,
                              TypePtr type);
+mlir::Value unary_operation(mlir::Value rhs,
+                            ast::UnaryOpType op_type,
+                            TypePtr type);
 }  // namespace arithmetic
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
@@ -65,6 +65,15 @@ std::string ast::binary_op_type_to_string(ast::BinaryOpType type) {
     }
 }
 
+std::string ast::unary_op_type_to_string(ast::UnaryOpType type) {
+    switch (type) {
+        case ast::UnaryOpType::MINUS:
+            return "MINUS";
+        case ast::UnaryOpType::NOT:
+            return "NOT";
+    }
+}
+
 ast::Node::Node(Token* token) {
     if (token == nullptr) {
         return;
@@ -348,3 +357,23 @@ void ast::BinaryOperator::xml(int level) {
 
     std::cout << std::string(level * 4, ' ') << "</binary operator>\n";
 }
+
+ast::UnaryOperator::UnaryOperator(UnaryOpType type,
+                                  shared_ptr<Expression> rhs,
+                                  Token* token)
+    : Expression(rhs->get_type(), token) {
+    this->type = type;
+    this->rhs = rhs;
+}
+
+void ast::UnaryOperator::xml(int level) {
+    std::cout << std::string(level * 4, ' ') << "<binop op_type=\""
+              << ast::unary_op_type_to_string(type) << "\" type=\""
+              << get_type()->get_name() << "\">\n";
+
+    std::cout << std::string((level + 1) * 4, ' ') << "<rhs>\n";
+    this->rhs->xml(level + 2);
+    std::cout << std::string((level + 1) * 4, ' ') << "</rhs>\n";
+
+    std::cout << std::string(level * 4, ' ') << "</binary operator>\n";
+}
diff --git a/src/ast/builder.cpp b/src/ast/builder.cpp
@@ -334,3 +334,22 @@ std::any Builder::visitAndOrCond(FusionParser::AndOrCondContext* ctx) {
 
     return to_node(binop);
 }
+
+std::any Builder::visitUnary(FusionParser::UnaryContext* ctx) {
+    Token* token;
+    ast::UnaryOpType type;
+
+    if (ctx->MINUS() != nullptr) {
+        type = ast::UnaryOpType::MINUS;
+        token = ctx->MINUS()->getSymbol();
+    } else if (ctx->BANG() != nullptr) {
+        type = ast::UnaryOpType::NOT;
+        token = ctx->BANG()->getSymbol();
+    } else {
+        throw std::runtime_error("Unrecognized unary operator");
+    }
+    auto rhs = cast_node(ast::Expression, visit(ctx->expr()));
+    auto binop = make_shared<ast::UnaryOperator>(type, rhs, token);
+
+    return to_node(binop);
+}
diff --git a/src/ast/passes/pass.cpp b/src/ast/passes/pass.cpp
@@ -45,6 +45,9 @@ void Pass::visit(shared_ptr<ast::Node> node) {
     try_visit(node, ast::Parameter, this->visit_parameter);
     try_visit(node, ast::Return, this->visit_return);
     try_visit(node, ast::BinaryOperator, this->visit_binary_operator);
+    try_visit(node, ast::UnaryOperator, this->visit_unary_operator);
+
+    throw std::runtime_error("node not added to pass manager");
 }
 
 void Pass::visit_block(shared_ptr<ast::Block> node) {
@@ -88,3 +91,7 @@ void Pass::visit_binary_operator(shared_ptr<ast::BinaryOperator> node) {
     visit(node->lhs);
     visit(node->rhs);
 }
+
+void Pass::visit_unary_operator(shared_ptr<ast::UnaryOperator> node) {
+    visit(node->rhs);
+}
diff --git a/src/backend/expressions/arithmetic.cpp b/src/backend/expressions/arithmetic.cpp
@@ -1,8 +1,10 @@
 #include "backend/expressions/arithmetic.h"
 #include "ast/ast.h"
-#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
+#include "backend/types/boolean.h"
+#include "backend/types/integer.h"
 #include "shared/context.h"
 
+#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 
 namespace {
@@ -75,6 +77,16 @@ mlir::Value arithmetic::lte(mlir::Value lhs, mlir::Value rhs, TypePtr type) {
     return binary_equality(lhs, rhs, type, mlir::LLVM::ICmpPredicate::sle);
 }
 
+mlir::Value arithmetic::not_(mlir::Value value) {
+    mlir::Value f = boolean::create_bool(false);
+    return eq(f, value, ctx::t_bool);
+}
+
+mlir::Value arithmetic::negate(mlir::Value value, TypePtr type) {
+    mlir::Value neg_one = integer::create_i32(-1);
+    return mul(neg_one, value, type);
+}
+
 mlir::Value arithmetic::binary_equality(mlir::Value lhs,
                                         mlir::Value rhs,
                                         TypePtr type,
@@ -120,3 +132,14 @@ mlir::Value arithmetic::binary_operation(mlir::Value lhs,
             return or_(lhs, rhs, type);
     }
 }
+
+mlir::Value arithmetic::unary_operation(mlir::Value rhs,
+                                        ast::UnaryOpType op_type,
+                                        TypePtr type) {
+    switch (op_type) {
+        case ast::UnaryOpType::MINUS:
+            return negate(rhs, type);
+        case ast::UnaryOpType::NOT:
+            return not_(rhs);
+    }
+}
diff --git a/src/backend/visitor.cpp b/src/backend/visitor.cpp
@@ -30,6 +30,7 @@ mlir::Value Backend::visit(shared_ptr<ast::Node> node) {
     try_visit(node, ast::Parameter, this->visit_parameter);
     try_visit(node, ast::Return, this->visit_return);
     try_visit(node, ast::BinaryOperator, this->visit_binary_operator);
+    try_visit(node, ast::UnaryOperator, this->visit_unary_operator);
 
     throw std::runtime_error("node not added to backend visit function");
 }
@@ -134,3 +135,9 @@ mlir::Value Backend::visit_binary_operator(
 
     return arithmetic::binary_operation(lhs, rhs, node->type, node->get_type());
 }
+
+mlir::Value Backend::visit_unary_operator(shared_ptr<ast::UnaryOperator> node) {
+    mlir::Value rhs = visit(node->rhs);
+
+    return arithmetic::unary_operation(rhs, node->type, node->get_type());
+}
diff --git a/tests/input/operators/unary.in b/tests/input/operators/unary.in
@@ -0,0 +1,7 @@
+fn main(): i32 {
+    println(!true);
+    println(!false);
+    println(-5);
+
+    return 0; 
+}
diff --git a/tests/lli-temp.out b/tests/lli-temp.out
@@ -1,14 +1,3 @@
-8
-5
-1
-6
-2
-0
-1
-0
 0
 1
-0
-1
-1
-0
+-5
diff --git a/tests/output/operators/unary.out b/tests/output/operators/unary.out
@@ -0,0 +1,3 @@
+0
+1
+-5