Merge pull request lcompilers#623 from namannimmo10/binop2

Add support for more binary operations in the ASR
dylon · Jun 21, 2022 · 3f7aab5 · 3f7aab5
2 parents 4163cd7 + 236565d
commit 3f7aab5
Show file tree

Hide file tree

Showing 16 changed files with 159 additions and 10 deletions.
diff --git a/integration_tests/expr_05.py b/integration_tests/expr_05.py
@@ -23,6 +23,9 @@ def main0():
     a = 123282374
     b = 32771
     assert test_mod(a, b) == 30643
+    a = -5345
+    b = -534
+    assert a % b == -5
     a = -123282374
     b = 32771
     assert test_mod(a, b) == 2128

diff --git a/src/libasr/ASR.asdl b/src/libasr/ASR.asdl
@@ -318,7 +318,7 @@ ttype
     | Pointer(ttype type)
     | CPtr()
 
-binop = Add | Sub | Mul | Div | Pow
+binop = Add | Sub | Mul | Div | Pow | BitAnd | BitOr | BitXor | BitLShift | BitRShift
 
 logicalbinop = And | Or | Xor | NEqv | Eqv
 

diff --git a/src/libasr/asr_utils.cpp b/src/libasr/asr_utils.cpp
@@ -388,6 +388,9 @@ bool is_op_overloaded(ASR::binopType op, std::string& intrinsic_op_name,
             }
             break;
         }
+        default: {
+            throw LFortranException("Binary operator '" + ASRUtils::binop_to_str(op) + "' not supported yet");
+        }
     }
     if( result && curr_scope->get_symbol(intrinsic_op_name) == nullptr ) {
         result = false;

diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h
@@ -261,6 +261,11 @@ static inline std::string binop_to_str(const ASR::binopType t) {
         case (ASR::binopType::Sub): { return " - "; }
         case (ASR::binopType::Mul): { return "*"; }
         case (ASR::binopType::Div): { return "/"; }
+        case (ASR::binopType::BitAnd): { return "&"; }
+        case (ASR::binopType::BitOr): { return "|"; }
+        case (ASR::binopType::BitXor): { return "^"; }
+        case (ASR::binopType::BitLShift): { return "<<"; }
+        case (ASR::binopType::BitRShift): { return ">>"; }
         default : throw LFortranException("Cannot represent the binary operator as a string");
     }
 }

diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp
@@ -3258,6 +3258,26 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 tmp = builder->CreateFPToSI(tmp, type);
                 break;
             };
+            case ASR::binopType::BitOr: {
+                tmp = builder->CreateOr(left_val, right_val);
+                break;
+            }
+            case ASR::binopType::BitAnd: {
+                tmp = builder->CreateAnd(left_val, right_val);
+                break;
+            }
+            case ASR::binopType::BitXor: {
+                tmp = builder->CreateXor(left_val, right_val);
+                break;
+            }
+            case ASR::binopType::BitLShift: {
+                tmp = builder->CreateShl(left_val, right_val);
+                break;
+            }
+            case ASR::binopType::BitRShift: {
+                tmp = builder->CreateAShr(left_val, right_val);
+                break;
+            }
         }
     }
 
@@ -3305,6 +3325,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 tmp = builder->CreateCall(fn_pow, {left_val, right_val});
                 break;
             };
+            default: {
+                throw CodeGenError("Binary operator '" + ASRUtils::binop_to_str(x.m_op) + "' not supported",
+                    x.base.base.loc);
+            }
         }
     }
 
@@ -3370,6 +3394,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 }
                 break;
             };
+            default: {
+                throw CodeGenError("Binary operator '" + ASRUtils::binop_to_str(x.m_op) + "' not supported",
+                    x.base.base.loc);
+            }
         }
         tmp = lfortran_complex_bin_op(left_val, right_val, fn_name, type);
     }

diff --git a/src/libasr/codegen/asr_to_x86.cpp b/src/libasr/codegen/asr_to_x86.cpp
@@ -328,10 +328,9 @@ class ASRToX86Visitor : public ASR::BaseVisitor<ASRToX86Visitor>
                 m_a.asm_div_r32(X86Reg::ecx);
                 break;
             };
-            case ASR::binopType::Pow: {
-                throw CodeGenError("Pow not implemented yet.");
-                break;
-            };
+            default: {
+                throw CodeGenError("Binary operator '" + ASRUtils::binop_to_str(x.m_op) + "' not supported yet");
+            }
         }
     }
 

diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp
@@ -1251,6 +1251,23 @@ class CommonVisitor : public AST::BaseVisitor<Derived> {
                     case (ASR::binopType::Mul): { result = left_value * right_value; break; }
                     case (ASR::binopType::Div): { result = left_value / right_value; break; }
                     case (ASR::binopType::Pow): { result = std::pow(left_value, right_value); break; }
+                    case (ASR::binopType::BitAnd): { result = left_value & right_value; break; }
+                    case (ASR::binopType::BitOr): { result = left_value | right_value; break; }
+                    case (ASR::binopType::BitXor): { result = left_value ^ right_value; break; }
+                    case (ASR::binopType::BitLShift): {
+                        if (right_value < 0) {
+                            throw SemanticError("Negative shift count not allowed.", loc);
+                        }
+                        result = left_value << right_value;
+                        break;
+                    }
+                    case (ASR::binopType::BitRShift): {
+                        if (right_value < 0) {
+                            throw SemanticError("Negative shift count not allowed.", loc);
+                        }
+                        result = left_value >> right_value;
+                        break;
+                    }
                     default: { LFORTRAN_ASSERT(false); } // should never happen
                 }
                 value = ASR::down_cast<ASR::expr_t>(ASR::make_IntegerConstant_t(
@@ -1261,6 +1278,11 @@ class CommonVisitor : public AST::BaseVisitor<Derived> {
 
         } else if (ASRUtils::is_real(*dest_type)) {
 
+            if (op == ASR::binopType::BitAnd || op == ASR::binopType::BitOr || op == ASR::binopType::BitXor ||
+                op == ASR::binopType::BitLShift || op == ASR::binopType::BitRShift) {
+                throw SemanticError("Unsupported binary operation on floats: '" + ASRUtils::binop_to_str(op) + "'", loc);
+            }
+
             if (ASRUtils::expr_value(left) != nullptr && ASRUtils::expr_value(right) != nullptr) {
                 double left_value = ASR::down_cast<ASR::RealConstant_t>(
                                                     ASRUtils::expr_value(left))->m_r;
@@ -1283,6 +1305,11 @@ class CommonVisitor : public AST::BaseVisitor<Derived> {
 
         } else if (ASRUtils::is_complex(*dest_type)) {
 
+            if (op == ASR::binopType::BitAnd || op == ASR::binopType::BitOr || op == ASR::binopType::BitXor ||
+                op == ASR::binopType::BitLShift || op == ASR::binopType::BitRShift) {
+                throw SemanticError("Unsupported binary operation on complex: '" + ASRUtils::binop_to_str(op) + "'", loc);
+            }
+
             if (ASRUtils::expr_value(left) != nullptr && ASRUtils::expr_value(right) != nullptr) {
                 ASR::ComplexConstant_t *left0 = ASR::down_cast<ASR::ComplexConstant_t>(
                                                                 ASRUtils::expr_value(left));
@@ -1567,12 +1594,12 @@ class CommonVisitor : public AST::BaseVisitor<Derived> {
             case (AST::operatorType::Div) : { op = ASR::binopType::Div; break; }
             case (AST::operatorType::FloorDiv) : {op = ASR::binopType::Div; break;}
             case (AST::operatorType::Pow) : { op = ASR::binopType::Pow; break; }
+            case (AST::operatorType::BitOr) : { op = ASR::binopType::BitOr; break; }
+            case (AST::operatorType::BitAnd) : { op = ASR::binopType::BitAnd; break; }
+            case (AST::operatorType::BitXor) : { op = ASR::binopType::BitXor; break; }
+            case (AST::operatorType::LShift) : { op = ASR::binopType::BitLShift; break; }
+            case (AST::operatorType::RShift) : { op = ASR::binopType::BitRShift; break; }
             case (AST::operatorType::Mod) : { op_name = "_mod"; break; }
-            case (AST::operatorType::BitOr) : { op_name = "_bitwise_or"; break; }
-            case (AST::operatorType::BitAnd) : { op_name = "_bitwise_and"; break; }
-            case (AST::operatorType::BitXor) : { op_name = "_bitwise_xor"; break; }
-            case (AST::operatorType::LShift) : { op_name = "_bitwise_lshift"; break; }
-            case (AST::operatorType::RShift) : { op_name = "_bitwise_rshift"; break; }
             default : {
                 throw SemanticError("Binary operator type not supported",
                     x.base.base.loc);

diff --git a/tests/errors/test_bitwise_on_complex.py b/tests/errors/test_bitwise_on_complex.py
@@ -0,0 +1,11 @@
+from ltypes import c32
+
+def f():
+    c1: c32
+    c1 = 4+5j
+    c2: c32
+    c2 = -5.6-3j
+    print(c1 | c2)
+
+
+f()
diff --git a/tests/errors/test_bitwise_on_float.py b/tests/errors/test_bitwise_on_float.py
@@ -0,0 +1,11 @@
+from ltypes import f32
+
+def f():
+    f1: f32
+    f1 = 4.5
+    f2: f32
+    f2 = 6.7
+    print(f1 << f2)
+
+
+f()
diff --git a/tests/reference/asr-expr_05-3a37324.json b/tests/reference/asr-expr_05-3a37324.json
@@ -0,0 +1,13 @@
+{
+    "basename": "asr-expr_05-3a37324",
+    "cmd": "lpython --show-asr --no-color {infile} -o {outfile}",
+    "infile": "tests/../integration_tests/expr_05.py",
+    "infile_hash": "ea9ac6984490195f1c6e1213faf8547b8b4c30a55af648ab3feb54d1",
+    "outfile": null,
+    "outfile_hash": null,
+    "stdout": "asr-expr_05-3a37324.stdout",
+    "stdout_hash": "73463c110205c774c50c282b97da4cb75532942b97ef855a0437362d",
+    "stderr": null,
+    "stderr_hash": null,
+    "returncode": 0
+}
diff --git a/tests/reference/asr-expr_05-3a37324.stdout b/tests/reference/asr-expr_05-3a37324.stdout
@@ -0,0 +1 @@
+(TranslationUnit (SymbolTable 1 {_lpython_main_program: (Subroutine (SymbolTable 102 {}) _lpython_main_program [] [(SubroutineCall 1 main0 () [] ())] Source Public Implementation () .false. .false.), _mod@__lpython_overloaded_0___mod: (ExternalSymbol 1 _mod@__lpython_overloaded_0___mod 6 __lpython_overloaded_0___mod lpython_builtin [] __lpython_overloaded_0___mod Public), lpython_builtin: (IntrinsicModule lpython_builtin), main0: (Subroutine (SymbolTable 4 {_mod: (ExternalSymbol 4 _mod 6 _mod lpython_builtin [] _mod Private), a: (Variable 4 a Local () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 4 b Local () () Default (Integer 4 []) Source Public Required .false.), i: (Variable 4 i Local () () Default (Integer 8 []) Source Public Required .false.), i1: (Variable 4 i1 Local (IntegerConstant 10 (Integer 4 [])) (IntegerConstant 10 (Integer 4 [])) Default (Integer 4 []) Source Public Required .false.), i2: (Variable 4 i2 Local (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) Default (Integer 4 []) Source Public Required .false.), i3: (Variable 4 i3 Local (IntegerConstant 432534534 (Integer 4 [])) (IntegerConstant 432534534 (Integer 4 [])) Default (Integer 4 []) Source Public Required .false.), i4: (Variable 4 i4 Local (IntegerUnaryMinus (IntegerConstant 4325 (Integer 4 [])) (Integer 4 []) (IntegerConstant -4325 (Integer 4 []))) (IntegerConstant -4325 (Integer 4 [])) Default (Integer 4 []) Source Public Required .false.)}) main0 [] [(= (Var 4 a) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 4 b) (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 []))) ()) (Assert (Compare (FunctionCall 1 test_multiply () [((Var 4 a)) ((Var 4 b))] (Integer 4 []) () ()) Eq (IntegerUnaryMinus (IntegerConstant 50 (Integer 4 [])) (Integer 4 []) (IntegerConstant -50 (Integer 4 []))) (Logical 4 []) () ()) ()) (= (Var 4 i) (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) ()) ()) (= (Var 4 i) (IntegerBinOp (Var 4 i) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) ()) (Integer 8 []) ()) ()) (Assert (Compare (Var 4 i) Eq (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 8 []) ()) (Logical 4 []) () ()) ()) (= (Var 4 a) (IntegerConstant 2 (Integer 4 [])) ()) (= (Var 4 b) (IntegerConstant 5 (Integer 4 [])) ()) (Assert (Compare (FunctionCall 1 test_mod () [((Var 4 a)) ((Var 4 b))] (Integer 4 []) () ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) () ()) ()) (Assert (Compare (FunctionCall 1 test_mod () [((IntegerConstant 23 (Integer 4 []))) ((IntegerConstant 3 (Integer 4 [])))] (Integer 4 []) () ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) () ()) ()) (= (Var 4 a) (IntegerConstant 123282374 (Integer 4 [])) ()) (= (Var 4 b) (IntegerConstant 32771 (Integer 4 [])) ()) (Assert (Compare (FunctionCall 1 test_mod () [((Var 4 a)) ((Var 4 b))] (Integer 4 []) () ()) Eq (IntegerConstant 30643 (Integer 4 [])) (Logical 4 []) () ()) ()) (= (Var 4 a) (IntegerUnaryMinus (IntegerConstant 5345 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5345 (Integer 4 []))) ()) (= (Var 4 b) (IntegerUnaryMinus (IntegerConstant 534 (Integer 4 [])) (Integer 4 []) (IntegerConstant -534 (Integer 4 []))) ()) (Assert (Compare (FunctionCall 1 _mod@__lpython_overloaded_0___mod 4 _mod [((Var 4 a)) ((Var 4 b))] (Integer 4 []) () ()) Eq (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 []))) (Logical 4 []) () ()) ()) (= (Var 4 a) (IntegerUnaryMinus (IntegerConstant 123282374 (Integer 4 [])) (Integer 4 []) (IntegerConstant -123282374 (Integer 4 []))) ()) (= (Var 4 b) (IntegerConstant 32771 (Integer 4 [])) ()) (Assert (Compare (FunctionCall 1 test_mod () [((Var 4 a)) ((Var 4 b))] (Integer 4 []) () ()) Eq (IntegerConstant 2128 (Integer 4 [])) (Logical 4 []) () ()) ()) (Assert (Compare (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) BitOr (IntegerConstant 4 (Integer 4 [])) (Integer 4 []) (IntegerConstant 14 (Integer 4 []))) Eq (IntegerConstant 14 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (IntegerConstant 105346 (Integer 4 [])) (Integer 4 []) (IntegerConstant -105346 (Integer 4 []))) BitOr (IntegerUnaryMinus (IntegerConstant 32771 (Integer 4 [])) (Integer 4 []) (IntegerConstant -32771 (Integer 4 []))) (Integer 4 []) (IntegerConstant -32769 (Integer 4 []))) Eq (IntegerUnaryMinus (IntegerConstant 32769 (Integer 4 [])) (Integer 4 []) (IntegerConstant -32769 (Integer 4 []))) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) BitAnd (IntegerConstant 4 (Integer 4 [])) (Integer 4 []) (IntegerConstant 0 (Integer 4 []))) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (IntegerConstant 105346 (Integer 4 [])) (Integer 4 []) (IntegerConstant -105346 (Integer 4 []))) BitAnd (IntegerUnaryMinus (IntegerConstant 32771 (Integer 4 [])) (Integer 4 []) (IntegerConstant -32771 (Integer 4 []))) (Integer 4 []) (IntegerConstant -105348 (Integer 4 []))) Eq (IntegerUnaryMinus (IntegerConstant 105348 (Integer 4 [])) (Integer 4 []) (IntegerConstant -105348 (Integer 4 []))) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) BitXor (IntegerConstant 4 (Integer 4 [])) (Integer 4 []) (IntegerConstant 14 (Integer 4 []))) Eq (IntegerConstant 14 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (IntegerConstant 105346 (Integer 4 [])) (Integer 4 []) (IntegerConstant -105346 (Integer 4 []))) BitXor (IntegerUnaryMinus (IntegerConstant 32771 (Integer 4 [])) (Integer 4 []) (IntegerConstant -32771 (Integer 4 []))) (Integer 4 []) (IntegerConstant 72579 (Integer 4 []))) Eq (IntegerConstant 72579 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) BitRShift (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerConstant 5 (Integer 4 [])) BitLShift (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 10 (Integer 4 []))) Eq (IntegerConstant 10 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i1) BitLShift (Var 4 i2) (Integer 4 []) (IntegerConstant 160 (Integer 4 []))) Eq (IntegerConstant 160 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i1) BitRShift (Var 4 i2) (Integer 4 []) (IntegerConstant 0 (Integer 4 []))) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i1) BitAnd (Var 4 i2) (Integer 4 []) (IntegerConstant 0 (Integer 4 []))) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i1) BitOr (Var 4 i2) (Integer 4 []) (IntegerConstant 14 (Integer 4 []))) Eq (IntegerConstant 14 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i1) BitXor (Var 4 i2) (Integer 4 []) (IntegerConstant 14 (Integer 4 []))) Eq (IntegerConstant 14 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (Var 4 i1) (Integer 4 []) (IntegerConstant -10 (Integer 4 []))) BitXor (IntegerUnaryMinus (Var 4 i2) (Integer 4 []) (IntegerConstant -4 (Integer 4 []))) (Integer 4 []) (IntegerConstant 10 (Integer 4 []))) Eq (IntegerConstant 10 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i3) BitOr (Var 4 i4) (Integer 4 []) (IntegerConstant -225 (Integer 4 []))) Eq (IntegerUnaryMinus (IntegerConstant 225 (Integer 4 [])) (Integer 4 []) (IntegerConstant -225 (Integer 4 []))) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (Var 4 i4) BitRShift (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -541 (Integer 4 []))) Eq (IntegerUnaryMinus (IntegerConstant 541 (Integer 4 [])) (Integer 4 []) (IntegerConstant -541 (Integer 4 []))) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (Var 4 i3) (Integer 4 []) (IntegerConstant -432534534 (Integer 4 []))) BitAnd (Var 4 i4) (Integer 4 []) (IntegerConstant -432534758 (Integer 4 []))) Eq (IntegerUnaryMinus (IntegerConstant 432534758 (Integer 4 [])) (Integer 4 []) (IntegerConstant -432534758 (Integer 4 []))) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ()) (Assert (Compare (IntegerBinOp (IntegerUnaryMinus (Var 4 i3) (Integer 4 []) (IntegerConstant -432534534 (Integer 4 []))) BitXor (Var 4 i4) (Integer 4 []) (IntegerConstant 432530657 (Integer 4 []))) Eq (IntegerConstant 432530657 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 [])) ()) ())] Source Public Implementation () .false. .false.), main_program: (Program (SymbolTable 101 {}) main_program [] [(SubroutineCall 1 _lpython_main_program () [] ())]), test_mod: (Function (SymbolTable 3 {_lpython_return_variable: (Variable 3 _lpython_return_variable ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 3 _mod 6 _mod lpython_builtin [] _mod Private), a: (Variable 3 a In () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 3 b In () () Default (Integer 4 []) Source Public Required .false.)}) test_mod [(Var 3 a) (Var 3 b)] [(= (Var 3 _lpython_return_variable) (FunctionCall 1 _mod@__lpython_overloaded_0___mod 3 _mod [((Var 3 a)) ((Var 3 b))] (Integer 4 []) () ()) ()) (Return)] (Var 3 _lpython_return_variable) Source Public Implementation ()), test_multiply: (Function (SymbolTable 2 {_lpython_return_variable: (Variable 2 _lpython_return_variable ReturnVar () () Default (Integer 4 []) Source Public Required .false.), a: (Variable 2 a In () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 2 b In () () Default (Integer 4 []) Source Public Required .false.)}) test_multiply [(Var 2 a) (Var 2 b)] [(= (Var 2 _lpython_return_variable) (IntegerBinOp (Var 2 a) Mul (Var 2 b) (Integer 4 []) ()) ()) (Return)] (Var 2 _lpython_return_variable) Source Public Implementation ())}) [])
diff --git a/tests/reference/asr-test_bitwise_on_complex-dd9568b.json b/tests/reference/asr-test_bitwise_on_complex-dd9568b.json
@@ -0,0 +1,13 @@
+{
+    "basename": "asr-test_bitwise_on_complex-dd9568b",
+    "cmd": "lpython --show-asr --no-color {infile} -o {outfile}",
+    "infile": "tests/errors/test_bitwise_on_complex.py",
+    "infile_hash": "5e03de6348ffb4fa922d726b314eb95eef2f332404e6be94f0b20139",
+    "outfile": null,
+    "outfile_hash": null,
+    "stdout": null,
+    "stdout_hash": null,
+    "stderr": "asr-test_bitwise_on_complex-dd9568b.stderr",
+    "stderr_hash": "58f7acb7f7187308d38c7c97fcd9e34b2022c42be1b6583b95b379af",
+    "returncode": 2
+}