[mlir][openacc][NFC] Use assembly format for acc.loop

[clementval]

Summary

Use the assembly format with custom parser/printer
for specific clauses instead of a full custom parser/printer.

[PeteSteinfeld]

All builds and tests correctly and looks good.

[clementval]

Fix acc-kernels-loop tests

[clementval]

clang-format

flang/lib/Lower/OpenACC.cpp

createLoopOp(Fortran::lower::AbstractConverter &converter,
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
 
   mlir::Value workerNum;
   mlir::Value vectorNum;
   mlir::Value gangNum;
   mlir::Value gangStatic;
   llvm::SmallVector<mlir::Value, 2> tileOperands, privateOperands,
       reductionOperands;
-  std::int64_t executionMapping = mlir::acc::OpenACCExecMapping::NONE;
+  bool hasGang = false, hasVector = false, hasWorker = false;
 
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
     mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *gangClause =
             std::get_if<Fortran::parser::AccClause::Gang>(&clause.u)) {
       if (gangClause->v) {
         const Fortran::parser::AccGangArgument &x = *gangClause->v;
         if (const auto &gangNumValue =
if (const auto *gangClause =
           } else {
             // * was passed as value and will be represented as a special
             // constant.
             gangStatic = firOpBuilder.createIntegerConstant(
                 clauseLocation, firOpBuilder.getIndexType(), starCst);
           }
         }
       }
-      executionMapping |= mlir::acc::OpenACCExecMapping::GANG;
+      hasGang = true;
     } else if (const auto *workerClause =
                    std::get_if<Fortran::parser::AccClause::Worker>(&clause.u)) {
       if (workerClause->v) {
         workerNum = fir::getBase(converter.genExprValue(
             *Fortran::semantics::GetExpr(*workerClause->v), stmtCtx));
       }
-      executionMapping |= mlir::acc::OpenACCExecMapping::WORKER;
+      hasWorker = true;
     } else if (const auto *vectorClause =
                    std::get_if<Fortran::parser::AccClause::Vector>(&clause.u)) {
       if (vectorClause->v) {
         vectorNum = fir::getBase(converter.genExprValue(
             *Fortran::semantics::GetExpr(*vectorClause->v), stmtCtx));
       }
-      executionMapping |= mlir::acc::OpenACCExecMapping::VECTOR;
+      hasVector = true;
     } else if (const auto *tileClause =
                    std::get_if<Fortran::parser::AccClause::Tile>(&clause.u)) {
       const Fortran::parser::AccTileExprList &accTileExprList = tileClause->v;
       for (const auto &accTileExpr : accTileExprList.v) {
         const auto &expr =
             std::get<std::optional<Fortran::parser::ScalarIntConstantExpr>>(
                 accTileExpr.t);
         if (expr) {
createLoopOp(Fortran::lower::AbstractConverter &converter,
   addOperand(operands, operandSegments, vectorNum);
   addOperands(operands, operandSegments, tileOperands);
   addOperands(operands, operandSegments, privateOperands);
   addOperands(operands, operandSegments, reductionOperands);
 
   auto loopOp = createRegionOp<mlir::acc::LoopOp, mlir::acc::YieldOp>(
       firOpBuilder, currentLocation, operands, operandSegments);
 
-  loopOp.setExecMappingAttr(firOpBuilder.getI64IntegerAttr(executionMapping));
+  if (hasGang)
+    loopOp.setHasGangAttr(firOpBuilder.getUnitAttr());
+  if (hasWorker)
+    loopOp.setHasWorkerAttr(firOpBuilder.getUnitAttr());
+  if (hasVector)
+    loopOp.setHasVectorAttr(firOpBuilder.getUnitAttr());
 
   // Lower clauses mapped to attributes
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
     if (const auto *collapseClause =
             std::get_if<Fortran::parser::AccClause::Collapse>(&clause.u)) {
       const auto *expr = Fortran::semantics::GetExpr(collapseClause->v);
       const std::optional<int64_t> collapseValue =
           Fortran::evaluate::ToInt64(*expr);

flang/test/Lower/OpenACC/acc-kernels-loop.f90

!CHECK-NEXT: }{{$}}
 
   !$acc kernels loop gang(num: 8)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[GANGNUM1:%.*]] = arith.constant 8 : i32
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop gang(num: gangNum)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
  !$acc kernels loop gang(num: gangNum, static: gangStatic)
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc kernels loop vector(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[CONSTANT128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop vector([[CONSTANT128]]: i32) {
+!CHECK:        acc.loop vector([[CONSTANT128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop vector(vectorLength)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK:        acc.loop vector([[VECTORLENGTH]]: i32) {
+!CHECK:        acc.loop vector([[VECTORLENGTH]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop worker
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc kernels loop worker(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[WORKER128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop worker([[WORKER128]]: i32) {
+!CHECK:        acc.loop worker([[WORKER128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop collapse(2)
   DO i = 1, n

 
  !$acc kernels loop tile(2)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[TILESIZE:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
  !$acc kernels loop tile(*)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[TILESIZEM1:%.*]] = arith.constant -1 : i32
-!CHECK:        acc.loop tile([[TILESIZEM1]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZEM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop tile(2, 2)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.kernels {
 !CHECK:        [[TILESIZE1:%.*]] = arith.constant 2 : i32
 !CHECK:        [[TILESIZE2:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE1]]: i32, [[TILESIZE2]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE1]], [[TILESIZE2]] : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
   !$acc kernels loop tile(tileSize)
   DO i = 1, n
!CHECK-NEXT: }{{$}}
   !$acc kernels loop tile(tileSize, tileSize)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.kernels {
-!CHECK:        acc.loop tile(%{{.*}}: i32, %{{.*}}: i32) {
+!CHECK:        acc.loop tile(%{{.*}}, %{{.*}} : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.terminator
 !CHECK-NEXT: }{{$}}
 
 end subroutine

flang/test/Lower/OpenACC/acc-loop.f90

 !CHECK-NEXT: }{{$}}
 
   !$acc loop gang(num: 8)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      [[GANGNUM1:%.*]] = arith.constant 8 : i32
-!CHECK-NEXT: acc.loop gang(num=[[GANGNUM1]]: i32) {
+!CHECK-NEXT: acc.loop gang(num=[[GANGNUM1]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop gang(num: gangNum)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK-NEXT: acc.loop gang(num=[[GANGNUM2]]: i32) {
+!CHECK-NEXT: acc.loop gang(num=[[GANGNUM2]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc loop gang(num: gangNum, static: gangStatic)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
-!CHECK: acc.loop gang(num=%{{.*}}: i32, static=%{{.*}}: i32) {
+!CHECK: acc.loop gang(num=%{{.*}} : i32, static=%{{.*}} : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop vector
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.loop vector {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop vector(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK: [[CONSTANT128:%.*]] = arith.constant 128 : i32
-!CHECK:      acc.loop vector([[CONSTANT128]]: i32) {
+!CHECK:      acc.loop vector([[CONSTANT128]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop vector(vectorLength)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK:      acc.loop vector([[VECTORLENGTH]]: i32) {
+!CHECK:      acc.loop vector([[VECTORLENGTH]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
 !$acc loop worker
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.loop worker {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop worker(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK: [[WORKER128:%.*]] = arith.constant 128 : i32
-!CHECK:      acc.loop worker([[WORKER128]]: i32) {
+!CHECK:      acc.loop worker([[WORKER128]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop private(c)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
-!CHECK:      acc.loop private(%{{.*}}: !fir.ref<!fir.array<10x10xf32>>) {
+!CHECK:      acc.loop private(%{{.*}} : !fir.ref<!fir.array<10x10xf32>>) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop private(c, d)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
-!CHECK:      acc.loop private(%{{.*}}: !fir.ref<!fir.array<10x10xf32>>, %{{.*}}: !fir.ref<!fir.array<10x10xf32>>) {
+!CHECK:      acc.loop private(%{{.*}}, %{{.*}} : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop private(c) private(d)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
-!CHECK:      acc.loop private(%{{.*}}: !fir.ref<!fir.array<10x10xf32>>, %{{.*}}: !fir.ref<!fir.array<10x10xf32>>) {
+!CHECK:      acc.loop private(%{{.*}}, %{{.*}} : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop tile(2)
   DO i = 1, n
     a(i) = b(i)
   END DO
 !CHECK:      [[TILESIZE:%.*]] = arith.constant 2 : i32
-!CHECK:      acc.loop tile([[TILESIZE]]: i32) {
+!CHECK:      acc.loop tile([[TILESIZE]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc loop tile(*)
   DO i = 1, n
     a(i) = b(i)
   END DO
 !CHECK:      [[TILESIZEM1:%.*]] = arith.constant -1 : i32
-!CHECK:      acc.loop tile([[TILESIZEM1]]: i32) {
+!CHECK:      acc.loop tile([[TILESIZEM1]] : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop tile(2, 2)
   DO i = 1, n
     DO j = 1, n
       c(i, j) = d(i, j)
     END DO
   END DO
 
 !CHECK:      [[TILESIZE1:%.*]] = arith.constant 2 : i32
 !CHECK:      [[TILESIZE2:%.*]] = arith.constant 2 : i32
-!CHECK:      acc.loop tile([[TILESIZE1]]: i32, [[TILESIZE2]]: i32) {
+!CHECK:      acc.loop tile([[TILESIZE1]], [[TILESIZE2]] : i32, i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop tile(tileSize)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
-!CHECK:      acc.loop tile(%{{.*}}: i32) {
+!CHECK:      acc.loop tile(%{{.*}} : i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop tile(tileSize, tileSize)
   DO i = 1, n
     DO j = 1, n
       c(i, j) = d(i, j)
     END DO
   END DO
 
-!CHECK:      acc.loop tile(%{{.*}}: i32, %{{.*}}: i32) {
+!CHECK:      acc.loop tile(%{{.*}}, %{{.*}} : i32, i32) {
 !CHECK:        fir.do_loop
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc loop collapse(2)
   DO i = 1, n
     DO j = 1, n
       c(i, j) = d(i, j)

flang/test/Lower/OpenACC/acc-parallel-loop.f90

 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop private(a) firstprivate(b)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel firstprivate([[B]] : !fir.ref<!fir.array<10xf32>>) private([[A]] : !fir.ref<!fir.array<10xf32>>) {
-!CHECK:        acc.loop private([[A]]: !fir.ref<!fir.array<10xf32>>) {
+!CHECK:        acc.loop private([[A]] : !fir.ref<!fir.array<10xf32>>) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop seq
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc parallel loop gang(num: 8)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[GANGNUM1:%.*]] = arith.constant 8 : i32
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop gang(num: gangNum)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc parallel loop gang(num: gangNum, static: gangStatic)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
-!CHECK:        acc.loop gang(num=%{{.*}}: i32, static=%{{.*}}: i32) {
+!CHECK:        acc.loop gang(num=%{{.*}} : i32, static=%{{.*}} : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop vector
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc parallel loop vector(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[CONSTANT128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop vector([[CONSTANT128]]: i32) {
+!CHECK:        acc.loop vector([[CONSTANT128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop vector(vectorLength)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK:        acc.loop vector([[VECTORLENGTH]]: i32) {
+!CHECK:        acc.loop vector([[VECTORLENGTH]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop worker
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc parallel loop worker(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[WORKER128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop worker([[WORKER128]]: i32) {
+!CHECK:        acc.loop worker([[WORKER128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop collapse(2)
   DO i = 1, n

 
  !$acc parallel loop tile(2)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[TILESIZE:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc parallel loop tile(*)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[TILESIZEM1:%.*]] = arith.constant -1 : i32
-!CHECK:        acc.loop tile([[TILESIZEM1]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZEM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop tile(2, 2)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.parallel {
 !CHECK:        [[TILESIZE1:%.*]] = arith.constant 2 : i32
 !CHECK:        [[TILESIZE2:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE1]]: i32, [[TILESIZE2]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE1]], [[TILESIZE2]] : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop tile(tileSize)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.parallel {
-!CHECK:        acc.loop tile(%{{.*}}: i32) {
+!CHECK:        acc.loop tile(%{{.*}} : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc parallel loop tile(tileSize, tileSize)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.parallel {
-!CHECK:        acc.loop tile(%{{.*}}: i32, %{{.*}}: i32) {
+!CHECK:        acc.loop tile(%{{.*}}, %{{.*}} : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
 end subroutine acc_parallel_loop

flang/test/Lower/OpenACC/acc-serial-loop.f90

 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop private(a) firstprivate(b)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial firstprivate([[B]] : !fir.ref<!fir.array<10xf32>>) private([[A]] : !fir.ref<!fir.array<10xf32>>) {
-!CHECK:        acc.loop private([[A]]: !fir.ref<!fir.array<10xf32>>) {
+!CHECK:        acc.loop private([[A]] : !fir.ref<!fir.array<10xf32>>) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop seq
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc serial loop gang(num: 8)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[GANGNUM1:%.*]] = arith.constant 8 : i32
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop gang(num: gangNum)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]]: i32) {
+!CHECK-NEXT:   acc.loop gang(num=[[GANGNUM2]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc serial loop gang(num: gangNum, static: gangStatic)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
-!CHECK:        acc.loop gang(num=%{{.*}}: i32, static=%{{.*}}: i32) {
+!CHECK:        acc.loop gang(num=%{{.*}} : i32, static=%{{.*}} : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop vector
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc serial loop vector(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[CONSTANT128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop vector([[CONSTANT128]]: i32) {
+!CHECK:        acc.loop vector([[CONSTANT128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop vector(vectorLength)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
-!CHECK:        acc.loop vector([[VECTORLENGTH]]: i32) {
+!CHECK:        acc.loop vector([[VECTORLENGTH]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop worker
   DO i = 1, n
!CHECK-NEXT: }{{$}}
 
   !$acc serial loop worker(128)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[WORKER128:%.*]] = arith.constant 128 : i32
-!CHECK:        acc.loop worker([[WORKER128]]: i32) {
+!CHECK:        acc.loop worker([[WORKER128]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop collapse(2)
   DO i = 1, n

 
  !$acc serial loop tile(2)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[TILESIZE:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
  !$acc serial loop tile(*)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[TILESIZEM1:%.*]] = arith.constant -1 : i32
-!CHECK:        acc.loop tile([[TILESIZEM1]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZEM1]] : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop tile(2, 2)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.serial {
 !CHECK:        [[TILESIZE1:%.*]] = arith.constant 2 : i32
 !CHECK:        [[TILESIZE2:%.*]] = arith.constant 2 : i32
-!CHECK:        acc.loop tile([[TILESIZE1]]: i32, [[TILESIZE2]]: i32) {
+!CHECK:        acc.loop tile([[TILESIZE1]], [[TILESIZE2]] : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop tile(tileSize)
   DO i = 1, n
     a(i) = b(i)
   END DO
 
 !CHECK:      acc.serial {
-!CHECK:        acc.loop tile(%{{.*}}: i32) {
+!CHECK:        acc.loop tile(%{{.*}} : i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
   !$acc serial loop tile(tileSize, tileSize)
   DO i = 1, n
     DO j = 1, n
       d(i, j) = e(i, j)
     END DO
   END DO
 
 !CHECK:      acc.serial {
-!CHECK:        acc.loop tile(%{{.*}}: i32, %{{.*}}: i32) {
+!CHECK:        acc.loop tile(%{{.*}}, %{{.*}} : i32, i32) {
 !CHECK:          fir.do_loop
 !CHECK:          acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
 end subroutine acc_serial_loop

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_LoopOp : OpenACC_Op<"loop", [AttrSizedOperandSegments]> {
   let arguments = (ins OptionalAttr<I64Attr>:$collapse,
                        Optional<IntOrIndex>:$gangNum,
                        Optional<IntOrIndex>:$gangStatic,
                        Optional<IntOrIndex>:$workerNum,
                        Optional<IntOrIndex>:$vectorLength,
                        UnitAttr:$seq,
                        UnitAttr:$independent,
                        UnitAttr:$auto_,
+                       UnitAttr:$hasGang,
+                       UnitAttr:$hasWorker,
+                       UnitAttr:$hasVector,
                        Variadic<IntOrIndex>:$tileOperands,
                        Variadic<AnyType>:$privateOperands,
                        OptionalAttr<OpenACC_ReductionOpAttr>:$reductionOp,
-                       Variadic<AnyType>:$reductionOperands,
-                       DefaultValuedAttr<I64Attr, "0">:$exec_mapping);
+                       Variadic<AnyType>:$reductionOperands);
 
   let results = (outs Variadic<AnyType>:$results);
 
   let regions = (region AnyRegion:$region);
 
   let extraClassDeclaration = [{
-    static StringRef getCollapseAttrStrName() { return "collapse"; }
-    static StringRef getSeqAttrStrName() { return "seq"; }
-    static StringRef getIndependentAttrStrName() { return "independent"; }
     static StringRef getAutoAttrStrName() { return "auto"; }
-    static StringRef getExecutionMappingAttrStrName() { return "exec_mapping"; }
-    static StringRef getGangKeyword() { return "gang"; }
     static StringRef getGangNumKeyword() { return "num"; }
     static StringRef getGangStaticKeyword() { return "static"; }
-    static StringRef getVectorKeyword() { return "vector"; }
-    static StringRef getWorkerKeyword() { return "worker"; }
-    static StringRef getTileKeyword() { return "tile"; }
-    static StringRef getPrivateKeyword() { return "private"; }
-    static StringRef getReductionKeyword() { return "reduction"; }
   }];
+
   let hasCustomAssemblyFormat = 1;
+  let assemblyFormat = [{
+    oilist(
+        `gang` `` custom<GangClause>($gangNum, type($gangNum), $gangStatic, type($gangStatic), $hasGang)
+      | `worker` `` custom<WorkerClause>($workerNum, type($workerNum), $hasWorker)
+      | `vector` `` custom<VectorClause>($vectorLength, type($vectorLength), $hasVector)
+      | `private` `(` $privateOperands `:` type($privateOperands) `)`
+      | `tile` `(` $tileOperands `:` type($tileOperands) `)`
+      | `reduction` `(` $reductionOperands `:` type($reductionOperands) `)`
+    )
+    $region
+    ( `(` type($results)^ `)` )?
+    attr-dict-with-keyword
+  }];
+
   let hasVerifier = 1;
 }
 
 // Yield operation for the acc.loop and acc.parallel operations.
 def OpenACC_YieldOp : OpenACC_Op<"yield", [Terminator,
     ParentOneOf<["ParallelOp, LoopOp, SerialOp"]>]> {
   let summary = "Acc yield and termination operation";
 

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

static ParseResult parseRegions(OpAsmParser &parser, OperationState &state,
   for (Region *region : regions) {
     if (parser.parseRegion(*region, /*arguments=*/{}, /*argTypes=*/{}))
       return failure();
   }
 
   return success();
 }
 
-static ParseResult
-parseOperandList(OpAsmParser &parser, StringRef keyword,
-                 SmallVectorImpl<OpAsmParser::UnresolvedOperand> &args,
-                 SmallVectorImpl<Type> &argTypes, OperationState &result) {
-  if (failed(parser.parseOptionalKeyword(keyword)))
-    return success();
-
-  if (failed(parser.parseLParen()))
-    return failure();
-
-  // Exit early if the list is empty.
-  if (succeeded(parser.parseOptionalRParen()))
-    return success();
-
-  if (failed(parser.parseCommaSeparatedList([&]() {
-        OpAsmParser::UnresolvedOperand arg;
-        Type type;
-
-        if (parser.parseOperand(arg, /*allowResultNumber=*/false) ||
-            parser.parseColonType(type))
-          return failure();
-
-        args.push_back(arg);
-        argTypes.push_back(type);
-        return success();
-      })) ||
-      failed(parser.parseRParen()))
-    return failure();
-
-  return parser.resolveOperands(args, argTypes, parser.getCurrentLocation(),
-                                result.operands);
-}
-
-static void printOperandList(Operation::operand_range operands,
-                             StringRef listName, OpAsmPrinter &printer) {
-
-  if (!operands.empty()) {
-    printer << " " << listName << "(";
-    llvm::interleaveComma(operands, printer, [&](Value op) {
-      printer << op << ": " << op.getType();
-    });
-    printer << ")";
-  }
-}
-
-static ParseResult parseOperandAndType(OpAsmParser &parser,
-                                       OperationState &result) {
-  OpAsmParser::UnresolvedOperand operand;
-  Type type;
-  if (parser.parseOperand(operand) || parser.parseColonType(type) ||
-      parser.resolveOperand(operand, type, result.operands))
-    return failure();
-  return success();
-}
-
-/// Parse optional operand and its type wrapped in parenthesis.
-/// Example:
-///   `(` %vectorLength: i64 `)`
-static OptionalParseResult parseOptionalOperandAndType(OpAsmParser &parser,
-                                                       OperationState &result) {
-  if (succeeded(parser.parseOptionalLParen())) {
-    return failure(parseOperandAndType(parser, result) || parser.parseRParen());
-  }
-  return std::nullopt;
-}
-
-/// Parse optional operand with its type prefixed with prefixKeyword `=`.
-/// Example:
-///   num=%gangNum: i32
-static OptionalParseResult parserOptionalOperandAndTypeWithPrefix(
-    OpAsmParser &parser, OperationState &result, StringRef prefixKeyword) {
-  if (succeeded(parser.parseOptionalKeyword(prefixKeyword))) {
-    if (parser.parseEqual() || parseOperandAndType(parser, result))
-      return failure();
-    return success();
-  }
-  return std::nullopt;
-}
-
 static bool isComputeOperation(Operation *op) {
   return isa<acc::ParallelOp>(op) || isa<acc::LoopOp>(op);
 }
 
 namespace {
 /// Pattern to remove operation without region that have constant false `ifCond`
 /// and remove the condition from the operation if the `ifCond` is a true
 /// constant.
Value KernelsOp::getDataOperand(unsigned i) {
   numOptional += getSelfCond() ? 1 : 0;
   return getOperand(getWaitOperands().size() + numOptional + i);
 }
 
 //===----------------------------------------------------------------------===//
 // LoopOp
 //===----------------------------------------------------------------------===//
 
-/// Parse acc.loop operation
-/// operation := `acc.loop`
-///              (`gang` ( `(` (`num=` value)? (`,` `static=` value `)`)? )? )?
-///              (`vector` ( `(` value `)` )? )? (`worker` (`(` value `)`)? )?
-///              (`vector_length` `(` value `)`)?
-///              (`tile` `(` value-list `)`)?
-///              (`private` `(` value-list `)`)?
-///              (`reduction` `(` value-list `)`)?
-///              region attr-dict?
-ParseResult LoopOp::parse(OpAsmParser &parser, OperationState &result) {
-  Builder &builder = parser.getBuilder();
-  unsigned executionMapping = OpenACCExecMapping::NONE;
-  SmallVector<Type, 8> operandTypes;
-  SmallVector<OpAsmParser::UnresolvedOperand, 8> privateOperands,
-      reductionOperands;
-  SmallVector<OpAsmParser::UnresolvedOperand, 8> tileOperands;
-  OptionalParseResult gangNum, gangStatic, worker, vector;
-
-  // gang?
-  if (succeeded(parser.parseOptionalKeyword(LoopOp::getGangKeyword())))
-    executionMapping |= OpenACCExecMapping::GANG;
-
-  // optional gang operand
+static ParseResult
+parseGangClause(OpAsmParser &parser,
+                std::optional<OpAsmParser::UnresolvedOperand> &gangNum,
+                Type &gangNumType,
+                std::optional<OpAsmParser::UnresolvedOperand> &gangStatic,
+                Type &gangStaticType, UnitAttr &hasGang) {
+  hasGang = UnitAttr::get(parser.getBuilder().getContext());
+  // optional gang operands
   if (succeeded(parser.parseOptionalLParen())) {
-    gangNum = parserOptionalOperandAndTypeWithPrefix(
-        parser, result, LoopOp::getGangNumKeyword());
-    if (gangNum.has_value() && failed(*gangNum))
+    if (succeeded(parser.parseOptionalKeyword(LoopOp::getGangNumKeyword()))) {
+      if (parser.parseEqual())
+        return failure();
+      gangNum = OpAsmParser::UnresolvedOperand{};
+      if (parser.parseOperand(*gangNum) || parser.parseColonType(gangNumType))
         return failure();
+    } else {
+      gangNum = std::nullopt;
+    }
     // FIXME: Comma should require subsequent operands.
     (void)parser.parseOptionalComma();
-    gangStatic = parserOptionalOperandAndTypeWithPrefix(
-        parser, result, LoopOp::getGangStaticKeyword());
-    if (gangStatic.has_value() && failed(*gangStatic))
+    if (succeeded(
+            parser.parseOptionalKeyword(LoopOp::getGangStaticKeyword()))) {
+      gangStatic = OpAsmParser::UnresolvedOperand{};
+      if (parser.parseEqual())
+        return failure();
+      gangStatic = OpAsmParser::UnresolvedOperand{};
+      if (parser.parseOperand(*gangStatic) ||
+          parser.parseColonType(gangStaticType))
         return failure();
+    }
     // FIXME: Why allow optional last commas?
     (void)parser.parseOptionalComma();
     if (failed(parser.parseRParen()))
       return failure();
   }
-
-  // worker?
-  if (succeeded(parser.parseOptionalKeyword(LoopOp::getWorkerKeyword())))
-    executionMapping |= OpenACCExecMapping::WORKER;
-
-  // optional worker operand
-  worker = parseOptionalOperandAndType(parser, result);
-  if (worker.has_value() && failed(*worker))
-    return failure();
-
-  // vector?
-  if (succeeded(parser.parseOptionalKeyword(LoopOp::getVectorKeyword())))
-    executionMapping |= OpenACCExecMapping::VECTOR;
-
-  // optional vector operand
-  vector = parseOptionalOperandAndType(parser, result);
-  if (vector.has_value() && failed(*vector))
-    return failure();
-
-  // tile()?
-  if (failed(parseOperandList(parser, LoopOp::getTileKeyword(), tileOperands,
-                              operandTypes, result)))
-    return failure();
-
-  // private()?
-  if (failed(parseOperandList(parser, LoopOp::getPrivateKeyword(),
-                              privateOperands, operandTypes, result)))
-    return failure();
-
-  // reduction()?
-  if (failed(parseOperandList(parser, LoopOp::getReductionKeyword(),
-                              reductionOperands, operandTypes, result)))
-    return failure();
-
-  if (executionMapping != acc::OpenACCExecMapping::NONE)
-    result.addAttribute(LoopOp::getExecutionMappingAttrStrName(),
-                        builder.getI64IntegerAttr(executionMapping));
-
-  // Parse optional results in case there is a reduce.
-  if (parser.parseOptionalArrowTypeList(result.types))
-    return failure();
-
-  if (failed(parseRegions<LoopOp>(parser, result)))
-    return failure();
-
-  result.addAttribute(LoopOp::getOperandSegmentSizeAttr(),
-                      builder.getDenseI32ArrayAttr(
-                          {static_cast<int32_t>(gangNum.has_value() ? 1 : 0),
-                           static_cast<int32_t>(gangStatic.has_value() ? 1 : 0),
-                           static_cast<int32_t>(worker.has_value() ? 1 : 0),
-                           static_cast<int32_t>(vector.has_value() ? 1 : 0),
-                           static_cast<int32_t>(tileOperands.size()),
-                           static_cast<int32_t>(privateOperands.size()),
-                           static_cast<int32_t>(reductionOperands.size())}));
-
-  if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
-    return failure();
-
   return success();
 }
 
-void LoopOp::print(OpAsmPrinter &printer) {
-  unsigned execMapping = getExecMapping();
-  if (execMapping & OpenACCExecMapping::GANG) {
-    printer << " " << LoopOp::getGangKeyword();
-    Value gangNum = getGangNum();
-    Value gangStatic = getGangStatic();
-
-    // Print optional gang operands
-    if (gangNum || gangStatic) {
-      printer << "(";
-      if (gangNum) {
-        printer << LoopOp::getGangNumKeyword() << "=" << gangNum << ": "
-                << gangNum.getType();
-        if (gangStatic)
-          printer << ", ";
-      }
-      if (gangStatic)
-        printer << LoopOp::getGangStaticKeyword() << "=" << gangStatic << ": "
-                << gangStatic.getType();
-      printer << ")";
-    }
-  }
+void printGangClause(OpAsmPrinter &p, Operation *op, Value gangNum,
+                     Type gangNumType, Value gangStatic, Type gangStaticType,
+                     UnitAttr hasGang) {
+    p << "(";
+      p << LoopOp::getGangNumKeyword() << "=" << gangNum << " : "
+        << gangNumType;
+        p << ", ";
+      p << LoopOp::getGangStaticKeyword() << "=" << gangStatic << " : "
+        << gangStaticType;
+    p << ")";
 
-  if (execMapping & OpenACCExecMapping::WORKER) {
-    printer << " " << LoopOp::getWorkerKeyword();
-
-    // Print optional worker operand if present
-    if (Value workerNum = getWorkerNum())
-      printer << "(" << workerNum << ": " << workerNum.getType() << ")";
+static ParseResult
+parseWorkerClause(OpAsmParser &parser,
+                  std::optional<OpAsmParser::UnresolvedOperand> &workerNum,
+                  Type &workerNumType, UnitAttr &hasWorker) {
+  hasWorker = UnitAttr::get(parser.getBuilder().getContext());
+  if (succeeded(parser.parseOptionalLParen())) {
+    workerNum = OpAsmParser::UnresolvedOperand{};
+    if (parser.parseOperand(*workerNum) ||
+        parser.parseColonType(workerNumType) || parser.parseRParen())
+      return failure();
   }
-
-  if (execMapping & OpenACCExecMapping::VECTOR) {
-    printer << " " << LoopOp::getVectorKeyword();
-
-    // Print optional vector operand if present
-    if (Value vectorLength = this->getVectorLength())
-      printer << "(" << vectorLength << ": " << vectorLength.getType() << ")";
-  }
+  return success();
 
-  // tile()?
-  printOperandList(getTileOperands(), LoopOp::getTileKeyword(), printer);
-
-  // private()?
-  printOperandList(getPrivateOperands(), LoopOp::getPrivateKeyword(), printer);
-
-  // reduction()?
-  printOperandList(getReductionOperands(), LoopOp::getReductionKeyword(),
-                   printer);
-
-  if (getNumResults() > 0)
-    printer << " -> (" << getResultTypes() << ")";
+void printWorkerClause(OpAsmPrinter &p, Operation *op, Value workerNum,
+                       Type workerNumType, UnitAttr hasWorker) {
+  if (workerNum)
+    p << "(" << workerNum << " : " << workerNumType << ")";
+}
 
-  printer << ' ';
-  printer.printRegion(getRegion(),
-                      /*printEntryBlockArgs=*/false,
-                      /*printBlockTerminators=*/true);
+static ParseResult
+parseVectorClause(OpAsmParser &parser,
+                  std::optional<OpAsmParser::UnresolvedOperand> &vectorLength,
+                  Type &vectorLengthType, UnitAttr &hasVector) {
+  hasVector = UnitAttr::get(parser.getBuilder().getContext());
+  if (succeeded(parser.parseOptionalLParen())) {
+    vectorLength = OpAsmParser::UnresolvedOperand{};
+    if (parser.parseOperand(*vectorLength) ||
+        parser.parseColonType(vectorLengthType) || parser.parseRParen())
+      return failure();
+  }
+  return success();
+}
 
-  printer.printOptionalAttrDictWithKeyword(
-      (*this)->getAttrs(), {LoopOp::getExecutionMappingAttrStrName(),
-                            LoopOp::getOperandSegmentSizeAttr()});
+void printVectorClause(OpAsmPrinter &p, Operation *op, Value vectorLength,
+                       Type vectorLengthType, UnitAttr hasVector) {
+  if (vectorLength)
+    p << "(" << vectorLength << " : " << vectorLengthType << ")";
 }
 
 LogicalResult acc::LoopOp::verify() {
   // auto, independent and seq attribute are mutually exclusive.
   if ((getAuto_() && (getIndependent() || getSeq())) ||
       (getIndependent() && getSeq())) {
-    return emitError("only one of " + acc::LoopOp::getAutoAttrStrName() + ", " +
-                     acc::LoopOp::getIndependentAttrStrName() + ", " +
-                     acc::LoopOp::getSeqAttrStrName() +
-                     " can be present at the same time");
+    return emitError() << "only one of \"" << acc::LoopOp::getAutoAttrStrName()
+                       << "\", " << getIndependentAttrName() << ", "
+                       << getSeqAttrName()
+                       << " can be present at the same time";
   }
 
   // Gang, worker and vector are incompatible with seq.
-  if (getSeq() && getExecMapping() != OpenACCExecMapping::NONE)
+  if (getSeq() && (getHasGang() || getHasWorker() || getHasVector()))
     return emitError("gang, worker or vector cannot appear with the seq attr");
 
   // Check non-empty body().
   if (getRegion().empty())
     return emitError("expected non-empty body.");
 
   return success();
 }

mlir/test/Dialect/OpenACC/invalid.mlir

 // -----
 
 // expected-error@+1 {{expected non-empty body.}}
 acc.loop {
 }
 
 // -----
 
-// expected-error@+1 {{only one of auto, independent, seq can be present at the same time}}
+// expected-error@+1 {{only one of "auto", "independent", "seq" can be present at the same time}}
 acc.loop {
   acc.yield
 } attributes {auto_, seq}
 
 // -----
 
 // expected-error@+1 {{at least one operand or the default attribute must appear on the data operation}}
 acc.data {

mlir/test/Dialect/OpenACC/ops.mlir

func.func @testloopop() -> () {
   acc.loop gang(num=%i64Value: i64, static=%i64Value: i64) worker(%i64Value: i64) vector(%i64Value: i64) {
     "test.openacc_dummy_op"() : () -> ()
     acc.yield
   }
   acc.loop gang(num=%i32Value: i32, static=%idxValue: index) {
     "test.openacc_dummy_op"() : () -> ()
     acc.yield
   }
-  acc.loop tile(%i64Value: i64, %i64Value: i64) {
+  acc.loop tile(%i64Value, %i64Value : i64, i64) {
     "test.openacc_dummy_op"() : () -> ()
     acc.yield
   }
-  acc.loop tile(%i32Value: i32, %i32Value: i32) {
+  acc.loop tile(%i32Value, %i32Value : i32, i32) {
     "test.openacc_dummy_op"() : () -> ()
     acc.yield
   }
   return
 }
 
 // CHECK:      [[I64VALUE:%.*]] = arith.constant 1 : i64
 // CHECK-NEXT: [[I32VALUE:%.*]] = arith.constant 128 : i32
 // CHECK-NEXT: [[IDXVALUE:%.*]] = arith.constant 8 : index
 // CHECK:      acc.loop gang worker vector {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop gang(num=[[I64VALUE]]: i64) {
+// CHECK:      acc.loop gang(num=[[I64VALUE]] : i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop gang(static=[[I64VALUE]]: i64) {
+// CHECK:      acc.loop gang(static=[[I64VALUE]] : i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop worker([[I64VALUE]]: i64) {
+// CHECK:      acc.loop worker([[I64VALUE]] : i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop worker([[I32VALUE]]: i32) {
+// CHECK:      acc.loop worker([[I32VALUE]] : i32) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop worker([[IDXVALUE]]: index) {
+// CHECK:      acc.loop worker([[IDXVALUE]] : index) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop vector([[I64VALUE]]: i64) {
+// CHECK:      acc.loop vector([[I64VALUE]] : i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop vector([[I32VALUE]]: i32) {
+// CHECK:      acc.loop vector([[I32VALUE]] : i32) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop vector([[IDXVALUE]]: index) {
+// CHECK:      acc.loop vector([[IDXVALUE]] : index) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop gang(num=[[I64VALUE]]: i64) worker vector {
+// CHECK:      acc.loop gang(num=[[I64VALUE]] : i64) worker vector {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop gang(num=[[I64VALUE]]: i64, static=[[I64VALUE]]: i64) worker([[I64VALUE]]: i64) vector([[I64VALUE]]: i64) {
+// CHECK:      acc.loop gang(num=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64) worker([[I64VALUE]] : i64) vector([[I64VALUE]] : i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop gang(num=[[I32VALUE]]: i32, static=[[IDXVALUE]]: index) {
+// CHECK:      acc.loop gang(num=[[I32VALUE]] : i32, static=[[IDXVALUE]] : index) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop tile([[I64VALUE]]: i64, [[I64VALUE]]: i64) {
+// CHECK:      acc.loop tile([[I64VALUE]], [[I64VALUE]] : i64, i64) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
-// CHECK:      acc.loop tile([[I32VALUE]]: i32, [[I32VALUE]]: i32) {
+// CHECK:      acc.loop tile([[I32VALUE]], [[I32VALUE]] : i32, i32) {
 // CHECK-NEXT:   "test.openacc_dummy_op"() : () -> ()
 // CHECK-NEXT:   acc.yield
 // CHECK-NEXT: }
 
 // -----
 
 func.func @acc_loop_multiple_block() {
   acc.parallel {