Merge pull request #616 from namannimmo10/split_binop

ASR: Split `BinOp` based on different types

Author: namannimmo10

src/libasr/ASR.asdl

@@ -212,13 +212,11 @@ stmt
 
 
 expr
-    = BoolOp(expr left, boolop op, expr right, ttype type, expr? value)
-    | BinOp(expr left, binop op, expr right, ttype type, expr? value, expr? overloaded)
+    = IfExp(expr test, expr body, expr orelse, ttype type, expr? value)
         -- Such as: (x, y+z), (3.0, 2.0) generally not known at compile time
     | ComplexConstructor(expr re, expr im, ttype type, expr? value)
     | NamedExpr(expr target, expr value, ttype type)
     | Compare(expr left, cmpop op, expr right, ttype type, expr? value, expr? overloaded)
-    | IfExp(expr test, expr body, expr orelse, ttype type, expr? value)
     | FunctionCall(symbol name, symbol? original_name,
             call_arg* args, ttype type, expr? value, expr? dt)
     | DerivedTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value)
@@ -228,12 +226,16 @@ expr
     | IntegerBOZ(int v, integerboz intboz_type, ttype? type)
     | IntegerBitNot(expr arg, ttype type, expr? value)
     | IntegerUnaryMinus(expr arg, ttype type, expr? value)
+    | IntegerBinOp(expr left, binop op, expr right, ttype type, expr? value)
     | RealConstant(float r, ttype type)
     | RealUnaryMinus(expr arg, ttype type, expr? value)
+    | RealBinOp(expr left, binop op, expr right, ttype type, expr? value)
     | ComplexConstant(float re, float im, ttype type)
     | ComplexUnaryMinus(expr arg, ttype type, expr? value)
+    | ComplexBinOp(expr left, binop op, expr right, ttype type, expr? value)
     | LogicalConstant(bool value, ttype type)
     | LogicalNot(expr arg, ttype type, expr? value)
+    | LogicalBinOp(expr left, logicalbinop op, expr right, ttype type, expr? value)
 
     | ListConstant(expr* args, ttype type)
     | ListLen(expr arg, ttype type, expr? value)
@@ -266,6 +268,7 @@ expr
     | ArrayPack(expr array, expr mask, expr? vector, ttype type, expr? value)
     | Transfer(expr source, expr mold, expr? size, ttype type, expr? value)
     | DerivedRef(expr v, symbol m, ttype type, expr? value)
+    | OverloadedBinOp(expr left, binop op, expr right, ttype type, expr? value, expr overloaded)
     | Cast(expr arg, cast_kind kind, ttype type, expr? value)
     | ComplexRe(expr arg, ttype type, expr? value)
     | ComplexIm(expr arg, ttype type, expr? value)
@@ -315,10 +318,10 @@ ttype
     | Pointer(ttype type)
     | CPtr()
 
-boolop = And | Or | Xor | NEqv | Eqv
-
 binop = Add | Sub | Mul | Div | Pow
 
+logicalbinop = And | Or | Xor | NEqv | Eqv
+
 cmpop = Eq | NotEq | Lt | LtE | Gt | GtE
 
 integerboz = Binary | Hex | Octal

src/libasr/asr_utils.h

@@ -226,12 +226,12 @@ static inline std::string cmpop_to_str(const ASR::cmpopType t) {
     }
 }
 
-static inline std::string boolop_to_str(const ASR::boolopType t) {
+static inline std::string logicalbinop_to_str(const ASR::logicalbinopType t) {
     switch (t) {
-        case (ASR::boolopType::And): { return " && "; }
-        case (ASR::boolopType::Or): { return " || "; }
-        case (ASR::boolopType::Eqv): { return " == "; }
-        case (ASR::boolopType::NEqv): { return " != "; }
+        case (ASR::logicalbinopType::And): { return " && "; }
+        case (ASR::logicalbinopType::Or): { return " || "; }
+        case (ASR::logicalbinopType::Eqv): { return " == "; }
+        case (ASR::logicalbinopType::NEqv): { return " != "; }
         default : throw LFortranException("Cannot represent the boolean operator as a string");
     }
 }
@@ -1074,7 +1074,7 @@ inline bool is_same_type_pointer(ASR::ttype_t* source, ASR::ttype_t* dest) {
                         a_len = -3;
                         break;
                     }
-                    case ASR::exprType::BinOp: {
+                    case ASR::exprType::IntegerBinOp: {
                         a_len = -3;
                         break;
                     }

src/libasr/codegen/asr_to_c_cpp.h

@@ -765,7 +765,20 @@ R"(#include <stdio.h>
         src = indent + dest_src + " = (" + type_src + ") " + source_src + ";\n";
     }
 
-    void visit_BinOp(const ASR::BinOp_t &x) {
+    void visit_IntegerBinOp(const ASR::IntegerBinOp_t &x) {
+        handle_BinOp(x);
+    }
+
+    void visit_RealBinOp(const ASR::RealBinOp_t &x) {
+        handle_BinOp(x);
+    }
+
+    void visit_ComplexBinOp(const ASR::ComplexBinOp_t &x) {
+        handle_BinOp(x);
+    }
+
+    template <typename T>
+    void handle_BinOp(const T &x) {
         self().visit_expr(*x.m_left);
         std::string left = std::move(src);
         int left_precedence = last_expr_precedence;
@@ -816,27 +829,27 @@ R"(#include <stdio.h>
         }
     }
 
-    void visit_BoolOp(const ASR::BoolOp_t &x) {
+    void visit_LogicalBinOp(const ASR::LogicalBinOp_t &x) {
         self().visit_expr(*x.m_left);
         std::string left = std::move(src);
         int left_precedence = last_expr_precedence;
         self().visit_expr(*x.m_right);
         std::string right = std::move(src);
         int right_precedence = last_expr_precedence;
         switch (x.m_op) {
-            case (ASR::boolopType::And): {
+            case (ASR::logicalbinopType::And): {
                 last_expr_precedence = 14;
                 break;
             }
-            case (ASR::boolopType::Or): {
+            case (ASR::logicalbinopType::Or): {
                 last_expr_precedence = 15;
                 break;
             }
-            case (ASR::boolopType::NEqv): {
+            case (ASR::logicalbinopType::NEqv): {
                 last_expr_precedence = 10;
                 break;
             }
-            case (ASR::boolopType::Eqv): {
+            case (ASR::logicalbinopType::Eqv): {
                 last_expr_precedence = 10;
                 break;
             }
@@ -848,7 +861,7 @@ R"(#include <stdio.h>
         } else {
             src += "(" + left + ")";
         }
-        src += ASRUtils::boolop_to_str(x.m_op);
+        src += ASRUtils::logicalbinop_to_str(x.m_op);
         if (right_precedence <= last_expr_precedence) {
             src += right;
         } else {