[mlir] Create a std op instead of chain of ops.

[hanchung]

Summary

1-bit integer is tricky in different dialects sometimes. E.g., there is no
arithmetic instructions on 1-bit integer in SPIR-V, i.e., spv.IMul %0, %1 : i1
is not valid. Instead, spv.LogicalAnd %0, %1 : i1 is valid. Creating the op
directly makes lowering easier because we don't need to match a complicated
pattern like !(!lhs && !rhs). Also, this matches the semantic better.

Also add assertions on inputs.

[mehdi_amini]

Can you provide a test for this?

The commit message could be made more clear as well

[nicolasvasilache]

Accepting conditioned on addressing @mehdi_amini 's comments.

[hanchung]

Add tests and update commit message.

mlir/lib/Dialect/AffineOps/EDSC/Builders.cpp

 ValueHandle mlir::edsc::op::operator!(ValueHandle value) {
   assert(value.getType().isInteger(1) && "expected boolean expression");
   return ValueHandle::create<ConstantIntOp>(1, 1) - value;
 }
 
 ValueHandle mlir::edsc::op::operator&&(ValueHandle lhs, ValueHandle rhs) {
   assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
   assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
-  return lhs * rhs;
+  return ValueHandle::create<AndOp>(lhs, rhs);
 }
 
 ValueHandle mlir::edsc::op::operator||(ValueHandle lhs, ValueHandle rhs) {
-  return !(!lhs && !rhs);
+  assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
+  assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
+  return ValueHandle::create<OrOp>(lhs, rhs);
 }
 
 static ValueHandle createIComparisonExpr(CmpIPredicate predicate,
                                          ValueHandle lhs, ValueHandle rhs) {
   auto lhsType = lhs.getType();
   auto rhsType = rhs.getType();
   (void)lhsType;
   (void)rhsType;

mlir/test/EDSC/builder-api-test.cpp

TEST_FUNC(zero_and_std_sign_extendi_op_i1_to_i8) {
   //      CHECK:     zexti %[[SRC1]] : i1 to i8
   //      CHECK:     %[[SRC2:.*]] = affine.load
   //      CHECK:     sexti %[[SRC2]] : i1 to i8
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
+TEST_FUNC(operator_or) {
+  auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
+  auto f = makeFunction("operator_or", {}, {i1Type, i1Type});
+
+  OpBuilder builder(f.getBody());
+  ScopedContext scope(builder, f.getLoc());
+
+  using op::operator||;
+  ValueHandle lhs(f.getArgument(0));
+  ValueHandle rhs(f.getArgument(1));
+  lhs || rhs;
+
+  // CHECK-LABEL: @operator_or
+  //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
+  //       CHECK: or [[ARG0]], [[ARG1]]
+  f.print(llvm::outs());
+  f.erase();
+}
+
+TEST_FUNC(operator_and) {
+  auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
+  auto f = makeFunction("operator_and", {}, {i1Type, i1Type});
+
+  OpBuilder builder(f.getBody());
+  ScopedContext scope(builder, f.getLoc());
+
+  using op::operator&&;
+  ValueHandle lhs(f.getArgument(0));
+  ValueHandle rhs(f.getArgument(1));
+  lhs &&rhs;
+
+  // CHECK-LABEL: @operator_and
+  //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
+  //       CHECK: and [[ARG0]], [[ARG1]]
+  f.print(llvm::outs());
+  f.erase();
+}
+
 TEST_FUNC(select_op_i32) {
   using namespace edsc::op;
   auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("select_op", {}, {memrefType});