Made changes as per comments from the reviewers

[mehdi_amini]

You need to keep everything in the same revision, you probably didn't amend the git commit locally and ended up creating a new revision.

[abidmalikwaterloo]

Yes, I just realized this as well.

[abidmalikwaterloo]

How can I remove this patch?

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

def ParallelOp : OpenMP_Op<"parallel", [AttrSizedOperandSegments]> {
 
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
   let parser = [{ return parseParallelOp(parser, result); }];
   let printer = [{ return printParallelOp(p, *this); }];
+  let verifier = [{ return ::verifyParallelOp(*this); }];
   
 }
 
 def TerminatorOp : OpenMP_Op<"terminator", [Terminator]> {
   let summary = "terminator for OpenMP regions";
   let description = [{
     A terminator operation for regions that appear in the body of OpenMP
     operation.  These regions are not expected to return any value so the
let description = [{
     
     The optional $nowait elliminates the implicit barrier so the parent task can make progress
     even if the target task is not yet completed.
     
     TODO:  private, map, is_device_ptr, firstprivate, depend, defaultmap, in_reduction
     
   }];
 
-  let arguments = (ins Optional<AnyInteger>:$if_expr,
+  let arguments = (ins Optional<I1>:$if_expr,
                        Optional<AnyInteger>:$device,
                        Optional<AnyInteger>:$thread_limit,
                        UnitAttr:$nowait);
 
   let regions = (region AnyRegion:$region);
   
   let builders = [
        OpBuilder<(ins "IntegerAttr":$if_expr,
                        "IntegerAttr":$device,
                        "IntegerAttr":$thread_limit,
                        "UnitAttr":$nowait)>
   ];
-    let parser   = [{ return parseTargetOp(parser, result); }];
-    let printer  = [{ return printTargetOp(p, *this); }];
-   // let verifier = [{ return ::verifyTargetOp(*this); }];
 }
 
 
 //===----------------------------------------------------------------------===//
 // 2.16 master Construct
 //===----------------------------------------------------------------------===//
 def MasterOp : OpenMP_Op<"master"> {
   let summary = "master construct";

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

void WsLoopOp::build(OpBuilder &builder, OperationState &result,
   if (buildBody) {
     OpBuilder::InsertionGuard guard(builder);
     unsigned numIVs = steps.size();
     SmallVector<Type, 8> argTypes(numIVs, steps.getType().front());
     builder.createBlock(bodyRegion, {}, argTypes);
   }
 }
 
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-// TargetOp
-//===----------------------------------------------------------------------===//
-
-void TargetOp::build(OpBuilder &builder, OperationState &state, IntegerAttr if_expr,
-                     IntegerAttr device, IntegerAttr thread_limit,
-                     UnitAttr nowait ) {
-    if (if_expr)
-      state.addAttribute("if_expr", if_expr);
-    if (device)
-      state.addAttribute("device", device);
-    if (thread_limit)
-        state.addAttribute("thread_limit", thread_limit);
-    if (nowait)
-      state.addAttribute("nowait", nowait);
-    
-}
-
-/// Parse a target operation.
-///
-/// operation ::= `omp.target' clause-list
-/// clause-list ::= clause | clause clause-list
-/// clause ::= if | thread_limit | device | nowait
-/// if ::= `if` `(` ssa-id `)`
-/// thread_limit ::= `thread_limit` `(` ssa-id-and-type`)`
-/// device ::= `device` `(`ssa-id-and-type`)`
-/// nowait ::= `nowait`
-/// TODO: other clauses
-/// TODO: Will update as  soon as the other clauses will be finalized
-
-static ParseResult parseTargetOp(OpAsmParser &parser,
-                                   OperationState &result){
-    
-    std::pair<OpAsmParser::OperandType, Type> ifCond;
-    std::pair<OpAsmParser::OperandType, Type> deviceNum;
-    std::pair<OpAsmParser::OperandType, Type> threadLimit;
-    
-    
-    std::array<int, 3> segments{0, 0, 0};
-    
-    StringRef keyword;
-    const StringRef opName = result.name.getStringRef();
-    
-    const int ifClausePos    = 0;
-    const int deviceNumPos   = 1;
-    const int threadLimitPos = 2;
-   
-    
-    
-    
-    while (succeeded(parser.parseOptionalKeyword(&keyword))) {
-        if (keyword == "if") {
-           // Fail if there was already another if condition.
-           if (segments[ifClausePos])
-             return allowedOnce(parser, "if", opName);
-           if (parser.parseLParen() || parser.parseOperand(ifCond.first) ||
-               parser.parseColonType(ifCond.second) || parser.parseRParen())
-             return failure();
-           segments[ifClausePos] = 1;
-         } else if (keyword == "thread_limit") {
-             // Fail if there was already another thread_limit clause.
-             if (segments[threadLimitPos])
-               return allowedOnce(parser, "thread_limit", opName);
-             if (parser.parseLParen() || parser.parseOperand(threadLimit.first) ||
-                 parser.parseColonType(threadLimit.second) || parser.parseRParen())
-               return failure();
-             segments[threadLimitPos] = 1;
-        } else if (keyword == "device") {
-            // Fail if there was already another device clause.
-            if (segments[deviceNumPos])
-              return allowedOnce(parser, "device", opName);
-            if (parser.parseLParen() || parser.parseOperand(deviceNum.first) ||
-                parser.parseColonType(deviceNum.second) || parser.parseRParen())
-              return failure();
-            segments[deviceNumPos] = 1;
-       } else if (keyword == "nowait") {
-          auto attr = UnitAttr::get(parser.getBuilder().getContext());
-          result.addAttribute("nowait", attr);
-        }
-    }
-    
-    if (segments[ifClausePos] &&
-        parser.resolveOperand(ifCond.first, ifCond.second, result.operands))
-      return failure();
-    
-    if (segments[threadLimitPos] &&
-        parser.resolveOperand(threadLimit.first, threadLimit.second, result.operands))
-      return failure();
-    
-    if (segments[deviceNumPos] &&
-        parser.resolveOperand(deviceNum.first, deviceNum.second, result.operands))
-      return failure();
-    
-    result.addAttribute("operand_segment_sizes",
-                        parser.getBuilder().getI32VectorAttr(segments));
-    
-    Region *body = result.addRegion();
-    SmallVector<OpAsmParser::OperandType, 4> regionArgs;
-    SmallVector<Type, 4> regionArgTypes;
-    if (parser.parseRegion(*body, regionArgs, regionArgTypes))
-      return failure();
-    
-    return success();
-}
-
-static void printTargetOp(OpAsmPrinter &p, TargetOp op) {
-    p << "omp.target";
-    if ( auto ifCond = op.if_expr())
-        p << " if (" << ifCond << " : " << ifCond.getType() << ")" ;
-    if ( auto threads = op.thread_limit())
-        p <<  " thread_limit (" << threads << " : " << threads.getType() << ")";
-    if ( auto devices = op.device())
-        p <<  " device (" << devices << " : " << devices.getType() << ")";
-    if (op.nowait())
-      p << " nowait";
-    
-  p.printRegion(op.getRegion());
-}
-
-
-
-
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"

mlir/test/Dialect/OpenMP/ops.mlir

omp.wsloop (%iv1, %iv2) : i32 = (%lb1, %lb2) to (%ub1, %ub2) step (%step1, %step2) {
     omp.yield
   }
 
   return
 }
 
 
 // CHECK-LABEL: omp_target
-func @omp_target(%if_cond : si32, %device : si32,  %num_threads : si32) -> () {
+func @omp_target(%if_cond : i1, %device : si32,  %num_threads : si32) -> () {
 
     // Test with optional operands; if_expr, device, thread_limit, and nowait.
     // CHECK: omp.target
     "omp.target"(%if_cond, %device, %num_threads) ({
        // CHECK: omp.terminator
        omp.terminator
-    }) {operand_segment_sizes = dense<[1,1,1]>: vector<3xi32>, nowait } : ( si32, si32, si32  ) -> ()
-
-    // CHECK: omp.barrier
-    omp.barrier
-
-    return
-}
-
-
-
-func @omp_target_pretty( %if_cond : si32, %device : si32, %thread_limit : si32) -> () {
-  // CHECK: omp.target
-  omp.target {
-  omp.terminator
-  }
-
-  // CHECK: omp.target device
-  omp.target device(%device : si32) {
-  omp.terminator
-  }   
+    }) {operand_segment_sizes = dense<[1,1,1]>: vector<3xi32>, nowait } : ( i1, si32, si32  ) -> ()
 
     // CHECK: omp.barrier
     omp.barrier
 
     return
 }