Format unary plus correctly

src/ast.cpp

@@ -105,9 +105,15 @@ namespace AST {
         case types::Unary::SubPrefix:
             out << "--" << this->m_expr->formatted();
             break;
-        case types::Unary::Negation:
+        case types::Unary::Not:
             out << "!" << this->m_expr->formatted();
             break;
+        case types::Unary::Negation:
+            out << "-" << this->m_expr->formatted();
+            break;
+        case types::Unary::Plus:
+            out << "+" << this->m_expr->formatted();
+            break;
         default:
             break;
         }

src/binops.cpp

@@ -167,10 +167,10 @@ namespace types {
                 });
         }
 
-        // Negation
+        // Not & Negation
         for (auto& ty : { int_ty, char_ty, bool_ty }) {
             definitions.push_back(UnopDefinition{
-                ty, types::Unary::Negation, ty,
+                ty, types::Unary::Not, ty,
                 [](codegen::Builder& builder, std::shared_ptr<Type> ty, llvm::Value* value) {
                     codegen::TypeMap structs {};
                     auto llvm_ty = ty->codegen(builder, structs);
@@ -181,6 +181,18 @@ namespace types {
                     return builder.builder->CreateSelect(cmp, const_1, const_0, "not_select");
                 }
                 });
+            definitions.push_back(UnopDefinition{
+                ty, types::Unary::Negation, ty,
+                [](codegen::Builder& builder, std::shared_ptr<Type>, llvm::Value* value) {
+                    return builder.builder->CreateNeg(value, "neg");
+                }
+                });
+            definitions.push_back(UnopDefinition{
+                ty, types::Unary::Plus, ty,
+                [](codegen::Builder&, std::shared_ptr<Type>, llvm::Value* value) {
+                    return value;
+                }
+                });
         }
 
         return definitions;

src/binops.h

@@ -20,7 +20,9 @@ namespace types {
         AddPrefix,
         SubPostfix,
         SubPrefix,
+        Not,
         Negation,
+        Plus,
     };
 
     int operator_precedence(BinOp& op);

src/parsing.cpp

@@ -334,6 +334,14 @@ namespace parsing {
                     };
                 }
                 else if (inner.peek().content == "!") {
+                    inner.next();
+                    auto expr = parse_primary_expression(inner, scope).unwrap();
+                    stream.m_position = inner.m_position;
+                    return std::unique_ptr<AST::Expression> {
+                        new AST::UnaryExpression(before_meta + inner.metadata(), std::move(expr), types::Unary::Not)
+                    };
+                }
+                else if (inner.peek().content == "-") {
                     inner.next();
                     auto expr = parse_primary_expression(inner, scope).unwrap();
                     stream.m_position = inner.m_position;
@@ -341,6 +349,14 @@ namespace parsing {
                         new AST::UnaryExpression(before_meta + inner.metadata(), std::move(expr), types::Unary::Negation)
                     };
                 }
+                else if (inner.peek().content == "+") {
+                    inner.next();
+                    auto expr = parse_primary_expression(inner, scope).unwrap();
+                    stream.m_position = inner.m_position;
+                    return std::unique_ptr<AST::Expression> {
+                        new AST::UnaryExpression(before_meta + inner.metadata(), std::move(expr), types::Unary::Plus)
+                    };
+                }
 
                 auto plain_expr = parse_plain_expression(inner, scope);
                 while (inner.peek().content == "(" || inner.peek().content == "[" || inner.peek().content == ".") {

test.c

@@ -52,7 +52,7 @@ int main() {
     printf("2d array: %d!\n", twod_array[0][0]);
 
     int counter = 0;
-    int a = !0;
+    int a = -500;
     printf("a: %d\n", a);
 
     return 0;