ASR,C,LLVM: Support UnsignedIntegerBitNot

Author: ubaidsk

src/libasr/ASR.asdl

@@ -250,6 +250,7 @@ expr
     | IntegerBinOp(expr left, binop op, expr right, ttype type, expr? value)
     | UnsignedIntegerConstant(int n, ttype type)
     | UnsignedIntegerUnaryMinus(expr arg, ttype type, expr? value)
+    | UnsignedIntegerBitNot(expr arg, ttype type, expr? value)
     | UnsignedIntegerCompare(expr left, cmpop op, expr right, ttype type, expr? value)
     | UnsignedIntegerBinOp(expr left, binop op, expr right, ttype type, expr? value)
     | RealConstant(float r, ttype type)

src/libasr/codegen/asr_to_c_cpp.h

@@ -2036,7 +2036,8 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
         }
     }
 
-    void visit_IntegerBitNot(const ASR::IntegerBitNot_t& x) {
+    template<typename T>
+    void handle_SU_IntegerBitNot(const T& x) {
         CHECK_FAST_C_CPP(compiler_options, x)
         self().visit_expr(*x.m_arg);
         int expr_precedence = last_expr_precedence;
@@ -2048,6 +2049,14 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
         }
     }
 
+    void visit_IntegerBitNot(const ASR::IntegerBitNot_t& x) {
+        handle_SU_IntegerBitNot(x);
+    }
+
+    void visit_UnsignedIntegerBitNot(const ASR::UnsignedIntegerBitNot_t& x) {
+        handle_SU_IntegerBitNot(x);
+    }
+
     void visit_IntegerUnaryMinus(const ASR::IntegerUnaryMinus_t &x) {
         handle_UnaryMinus(x);
     }

src/libasr/codegen/asr_to_llvm.cpp

@@ -6193,6 +6193,15 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         tmp = builder->CreateNot(tmp);
     }
 
+    void visit_UnsignedIntegerBitNot(const ASR::UnsignedIntegerBitNot_t &x) {
+        if (x.m_value) {
+            this->visit_expr_wrapper(x.m_value, true);
+            return;
+        }
+        this->visit_expr_wrapper(x.m_arg, true);
+        tmp = builder->CreateNot(tmp);
+    }
+
     void visit_IntegerUnaryMinus(const ASR::IntegerUnaryMinus_t &x) {
         if (x.m_value) {
             this->visit_expr_wrapper(x.m_value, true);

src/lpython/semantics/python_ast_to_asr.cpp

@@ -3410,6 +3410,17 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 tmp = ASR::make_IntegerBitNot_t(al, x.base.base.loc, operand, dest_type, value);
                 return;
             }
+            else if (ASRUtils::is_unsigned_integer(*operand_type)) {
+                if (ASRUtils::expr_value(operand) != nullptr) {
+                    int64_t op_value = ASR::down_cast<ASR::UnsignedIntegerConstant_t>(
+                                            ASRUtils::expr_value(operand))->m_n;
+                    uint64_t val = ~uint64_t(op_value);
+                    value = ASR::down_cast<ASR::expr_t>(ASR::make_UnsignedIntegerConstant_t(
+                        al, x.base.base.loc, val, operand_type));
+                }
+                tmp = ASR::make_UnsignedIntegerBitNot_t(al, x.base.base.loc, operand, dest_type, value);
+                return;
+            }
             else if (ASRUtils::is_real(*operand_type)) {
                 throw SemanticError("Unary operator '~' not supported for floats",
                     x.base.base.loc);