[mlir] Flip Async/GPU/MemRef/OpenACC/OpenMP/PDL dialects to prefixed

[rriddle]

Summary

This flips all of the remaining dialects to prefixed except for linalg, which
will be done in a followup.

[jpienaar]

Thanks!

flang/lib/Lower/OpenACC.cpp

genACCEnterDataOp(Fortran::lower::AbstractConverter &converter,
   addOperands(operands, operandSegments, createOperands);
   addOperands(operands, operandSegments, createZeroOperands);
   addOperands(operands, operandSegments, attachOperands);
 
   mlir::acc::EnterDataOp enterDataOp = createSimpleOp<mlir::acc::EnterDataOp>(
       firOpBuilder, currentLocation, operands, operandSegments);
 
   if (addAsyncAttr)
-    enterDataOp.asyncAttr(firOpBuilder.getUnitAttr());
+    enterDataOp.setAsyncAttr(firOpBuilder.getUnitAttr());
   if (addWaitAttr)
-    enterDataOp.waitAttr(firOpBuilder.getUnitAttr());
+    enterDataOp.setWaitAttr(firOpBuilder.getUnitAttr());
 }
 
 static void
 genACCExitDataOp(Fortran::lower::AbstractConverter &converter,
                  mlir::Location currentLocation,
                  Fortran::semantics::SemanticsContext &semanticsContext,
                  Fortran::lower::StatementContext &stmtCtx,
                  const Fortran::parser::AccClauseList &accClauseList) {
genACCExitDataOp(Fortran::lower::AbstractConverter &converter,
   addOperands(operands, operandSegments, copyoutOperands);
   addOperands(operands, operandSegments, deleteOperands);
   addOperands(operands, operandSegments, detachOperands);
 
   mlir::acc::ExitDataOp exitDataOp = createSimpleOp<mlir::acc::ExitDataOp>(
       firOpBuilder, currentLocation, operands, operandSegments);
 
   if (addAsyncAttr)
-    exitDataOp.asyncAttr(firOpBuilder.getUnitAttr());
+    exitDataOp.setAsyncAttr(firOpBuilder.getUnitAttr());
   if (addWaitAttr)
-    exitDataOp.waitAttr(firOpBuilder.getUnitAttr());
+    exitDataOp.setWaitAttr(firOpBuilder.getUnitAttr());
   if (addFinalizeAttr)
-    exitDataOp.finalizeAttr(firOpBuilder.getUnitAttr());
+    exitDataOp.setFinalizeAttr(firOpBuilder.getUnitAttr());
 }
 
 template <typename Op>
 static void
 genACCInitShutdownOp(Fortran::lower::AbstractConverter &converter,
                      mlir::Location currentLocation,
                      const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, deviceNum;
genACCUpdateOp(Fortran::lower::AbstractConverter &converter,
   addOperands(operands, operandSegments, deviceTypeOperands);
   addOperands(operands, operandSegments, hostOperands);
   addOperands(operands, operandSegments, deviceOperands);
 
   mlir::acc::UpdateOp updateOp = createSimpleOp<mlir::acc::UpdateOp>(
       firOpBuilder, currentLocation, operands, operandSegments);
 
   if (addAsyncAttr)
-    updateOp.asyncAttr(firOpBuilder.getUnitAttr());
+    updateOp.setAsyncAttr(firOpBuilder.getUnitAttr());
   if (addWaitAttr)
-    updateOp.waitAttr(firOpBuilder.getUnitAttr());
+    updateOp.setWaitAttr(firOpBuilder.getUnitAttr());
   if (addIfPresentAttr)
-    updateOp.ifPresentAttr(firOpBuilder.getUnitAttr());
+    updateOp.setIfPresentAttr(firOpBuilder.getUnitAttr());
 }
 
 static void
 genACC(Fortran::lower::AbstractConverter &converter,
        Fortran::semantics::SemanticsContext &semanticsContext,
        Fortran::lower::pft::Evaluation &eval,
        const Fortran::parser::OpenACCStandaloneConstruct &standaloneConstruct) {
   const auto &standaloneDirective =
static void genACC(Fortran::lower::AbstractConverter &converter,
   addOperand(operands, operandSegments, async);
   addOperand(operands, operandSegments, waitDevnum);
   addOperand(operands, operandSegments, ifCond);
 
   mlir::acc::WaitOp waitOp = createSimpleOp<mlir::acc::WaitOp>(
       firOpBuilder, currentLocation, operands, operandSegments);
 
   if (addAsyncAttr)
-    waitOp.asyncAttr(firOpBuilder.getUnitAttr());
+    waitOp.setAsyncAttr(firOpBuilder.getUnitAttr());
 }
 
 void Fortran::lower::genOpenACCConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::semantics::SemanticsContext &semanticsContext,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenACCConstruct &accConstruct) {
 

flang/lib/Lower/OpenMP.cpp

if (const auto &privateClause =
                        &clause.u)) {
       collectOmpObjectListSymbol(firstPrivateClause->v, privatizedSymbols);
     } else if (const auto &lastPrivateClause =
                    std::get_if<Fortran::parser::OmpClause::Lastprivate>(
                        &clause.u)) {
       // TODO: Add lastprivate support for sections construct, simd construct
       if (std::is_same_v<Op, omp::WsLoopOp>) {
         omp::WsLoopOp *wsLoopOp = dyn_cast<omp::WsLoopOp>(&op);
-        mlir::Operation *lastOper = wsLoopOp->region().back().getTerminator();
+        mlir::Operation *lastOper =
+            wsLoopOp->getRegion().back().getTerminator();
         firOpBuilder.setInsertionPoint(lastOper);
 
         // Our goal here is to introduce the following control flow
         // just before exiting the worksharing loop.
         // Say our wsloop is as follows:
         //
         // omp.wsloop {
         //    ...
if (const auto &privateClause =
             TODO(converter.getCurrentLocation(),
                  "Collapse clause with lastprivate");
         // Only generate the compare once in presence of multiple LastPrivate
         // clauses.
         if (!hasLastPrivateOp) {
           cmpOp = firOpBuilder.create<mlir::arith::CmpIOp>(
               wsLoopOp->getLoc(), mlir::arith::CmpIPredicate::eq,
               wsLoopOp->getRegion().front().getArguments()[0],
-              wsLoopOp->upperBound()[0]);
+              wsLoopOp->getUpperBound()[0]);
         }
         mlir::scf::IfOp ifOp = firOpBuilder.create<mlir::scf::IfOp>(
             wsLoopOp->getLoc(), cmpOp, /*else*/ false);
         lastPrivBlock = &ifOp.getThenRegion().front();
       } else {
         TODO(converter.getCurrentLocation(),
              "lastprivate clause in constructs other than worksharing-loop");
       }
static void threadPrivatizeVars(Fortran::lower::AbstractConverter &converter,
   // symbol value from that opeartion to create one ThreadprivateOp copy
   // operation inside the parallel region.
   auto genThreadprivateOp = [&](Fortran::lower::SymbolRef sym) -> mlir::Value {
     mlir::Value symOriThreadprivateValue = converter.getSymbolAddress(sym);
     mlir::Operation *op = symOriThreadprivateValue.getDefiningOp();
     assert(mlir::isa<mlir::omp::ThreadprivateOp>(op) &&
            "The threadprivate operation not created");
     mlir::Value symValue =
-        mlir::dyn_cast<mlir::omp::ThreadprivateOp>(op).sym_addr();
+        mlir::dyn_cast<mlir::omp::ThreadprivateOp>(op).getSymAddr();
     return firOpBuilder.create<mlir::omp::ThreadprivateOp>(
         currentLocation, symValue.getType(), symValue);
   };
 
   llvm::SetVector<const Fortran::semantics::Symbol *> threadprivateSyms;
   converter.collectSymbolSet(
       eval, threadprivateSyms,
       Fortran::semantics::Symbol::Flag::OmpThreadprivate);
static omp::ReductionDeclareOp createReductionDecl(
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   auto decl =
       module.lookupSymbol<mlir::omp::ReductionDeclareOp>(reductionOpName);
   if (!decl)
     decl =
         modBuilder.create<omp::ReductionDeclareOp>(loc, reductionOpName, type);
   else
     return decl;
-  builder.createBlock(&decl.initializerRegion(), decl.initializerRegion().end(),
-                      {type}, {loc});
-  builder.setInsertionPointToEnd(&decl.initializerRegion().back());
+  builder.createBlock(&decl.getInitializerRegion(),
+                      decl.getInitializerRegion().end(), {type}, {loc});
+  builder.setInsertionPointToEnd(&decl.getInitializerRegion().back());
   Value init = getReductionInitValue(loc, type, reductionOpName, builder);
   builder.create<omp::YieldOp>(loc, init);
 
-  builder.createBlock(&decl.reductionRegion(), decl.reductionRegion().end(),
-                      {type, type}, {loc, loc});
-  builder.setInsertionPointToEnd(&decl.reductionRegion().back());
-  mlir::Value op1 = decl.reductionRegion().front().getArgument(0);
-  mlir::Value op2 = decl.reductionRegion().front().getArgument(1);
+  builder.createBlock(&decl.getReductionRegion(),
+                      decl.getReductionRegion().end(), {type, type},
+                      {loc, loc});
+  builder.setInsertionPointToEnd(&decl.getReductionRegion().back());
+  mlir::Value op1 = decl.getReductionRegion().front().getArgument(0);
+  mlir::Value op2 = decl.getReductionRegion().front().getArgument(1);
 
   Value reductionOp;
   switch (intrinsicOp) {
   case Fortran::parser::DefinedOperator::IntrinsicOperator::Add:
     reductionOp =
         getReductionOperation<mlir::arith::AddFOp, mlir::arith::AddIOp>(
             builder, type, loc, op1, op2);
     break;
if (const auto &scheduleClause =
                 decl = createReductionDecl(
                     firOpBuilder, getReductionName(intrinsicOp, redType),
                     intrinsicOp, redType, currentLocation);
               } else {
                 TODO(currentLocation,
                      "Reduction of some types is not supported");
               }
               reductionDeclSymbols.push_back(SymbolRefAttr::get(
-                  firOpBuilder.getContext(), decl.sym_name()));
+                  firOpBuilder.getContext(), decl.getSymName()));
             }
           }
         }
       } else {
         TODO(currentLocation,
              "Reduction of intrinsic procedures is not supported");
       }
     } else if (const auto &simdlenClause =
static void genOMP(Fortran::lower::AbstractConverter &converter,
   // Handle attribute based clauses.
   for (const Fortran::parser::OmpClause &clause : loopOpClauseList.v) {
     if (const auto &orderedClause =
             std::get_if<Fortran::parser::OmpClause::Ordered>(&clause.u)) {
       if (orderedClause->v.has_value()) {
         const auto *expr = Fortran::semantics::GetExpr(orderedClause->v);
         const std::optional<std::int64_t> orderedClauseValue =
             Fortran::evaluate::ToInt64(*expr);
-        wsLoopOp.ordered_valAttr(
+        wsLoopOp.setOrderedValAttr(
             firOpBuilder.getI64IntegerAttr(*orderedClauseValue));
       } else {
-        wsLoopOp.ordered_valAttr(firOpBuilder.getI64IntegerAttr(0));
+        wsLoopOp.setOrderedValAttr(firOpBuilder.getI64IntegerAttr(0));
       }
     } else if (const auto &scheduleClause =
                    std::get_if<Fortran::parser::OmpClause::Schedule>(
                        &clause.u)) {
       mlir::MLIRContext *context = firOpBuilder.getContext();
       const auto &scheduleType = scheduleClause->v;
       const auto &scheduleKind =
           std::get<Fortran::parser::OmpScheduleClause::ScheduleType>(
               scheduleType.t);
       switch (scheduleKind) {
       case Fortran::parser::OmpScheduleClause::ScheduleType::Static:
-        wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(
+        wsLoopOp.setScheduleValAttr(omp::ClauseScheduleKindAttr::get(
             context, omp::ClauseScheduleKind::Static));
         break;
       case Fortran::parser::OmpScheduleClause::ScheduleType::Dynamic:
-        wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(
+        wsLoopOp.setScheduleValAttr(omp::ClauseScheduleKindAttr::get(
             context, omp::ClauseScheduleKind::Dynamic));
         break;
       case Fortran::parser::OmpScheduleClause::ScheduleType::Guided:
-        wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(
+        wsLoopOp.setScheduleValAttr(omp::ClauseScheduleKindAttr::get(
             context, omp::ClauseScheduleKind::Guided));
         break;
       case Fortran::parser::OmpScheduleClause::ScheduleType::Auto:
-        wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(
+        wsLoopOp.setScheduleValAttr(omp::ClauseScheduleKindAttr::get(
             context, omp::ClauseScheduleKind::Auto));
         break;
       case Fortran::parser::OmpScheduleClause::ScheduleType::Runtime:
-        wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(
+        wsLoopOp.setScheduleValAttr(omp::ClauseScheduleKindAttr::get(
             context, omp::ClauseScheduleKind::Runtime));
         break;
       }
       mlir::omp::ScheduleModifier scheduleModifier =
           getScheduleModifier(scheduleClause->v);
       if (scheduleModifier != mlir::omp::ScheduleModifier::none)
-        wsLoopOp.schedule_modifierAttr(
+        wsLoopOp.setScheduleModifierAttr(
             omp::ScheduleModifierAttr::get(context, scheduleModifier));
       if (getSIMDModifier(scheduleClause->v) !=
           mlir::omp::ScheduleModifier::none)
-        wsLoopOp.simd_modifierAttr(firOpBuilder.getUnitAttr());
+        wsLoopOp.setSimdModifierAttr(firOpBuilder.getUnitAttr());
     }
   }
   // In FORTRAN `nowait` clause occur at the end of `omp do` directive.
   // i.e
   // !$omp do
   // <...>
   // !$omp end do nowait
   if (const auto &endClauseList =
           std::get<std::optional<Fortran::parser::OmpEndLoopDirective>>(
               loopConstruct.t)) {
     const auto &clauseList =
         std::get<Fortran::parser::OmpClauseList>((*endClauseList).t);
     for (const Fortran::parser::OmpClause &clause : clauseList.v)
       if (std::get_if<Fortran::parser::OmpClause::Nowait>(&clause.u))
-        wsLoopOp.nowaitAttr(firOpBuilder.getUnitAttr());
+        wsLoopOp.setNowaitAttr(firOpBuilder.getUnitAttr());
   }
 
   createBodyOfOp<omp::WsLoopOp>(wsLoopOp, converter, currentLocation, eval,
                                 &loopOpClauseList, iv);
 }
 
 static void
 genOMP(Fortran::lower::AbstractConverter &converter,
if (name.empty()) {
       mlir::ModuleOp module = firOpBuilder.getModule();
       mlir::OpBuilder modBuilder(module.getBodyRegion());
       auto global = module.lookupSymbol<mlir::omp::CriticalDeclareOp>(name);
       if (!global)
         global = modBuilder.create<mlir::omp::CriticalDeclareOp>(
             currentLocation, name, hint);
       return firOpBuilder.create<mlir::omp::CriticalOp>(
           currentLocation, mlir::FlatSymbolRefAttr::get(
-                               firOpBuilder.getContext(), global.sym_name()));
+                               firOpBuilder.getContext(), global.getSymName()));
     }
   }();
   createBodyOfOp<omp::CriticalOp>(criticalOp, converter, currentLocation, eval);
 }
 
 static void
 genOMP(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,

flang/lib/Optimizer/Transforms/AffineDemotion.cpp

 
 class StdAllocConversion : public mlir::OpRewritePattern<memref::AllocOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   mlir::LogicalResult
   matchAndRewrite(memref::AllocOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<fir::AllocaOp>(op, convertMemRef(op.getType()),
-                                               op.memref());
+                                               op.getMemref());
     return success();
   }
 };
 
 class AffineDialectDemotion
     : public fir::impl::AffineDialectDemotionBase<AffineDialectDemotion> {
 public:
   void runOnOperation() override {

mlir/include/mlir/Dialect/Async/IR/AsyncDialect.td

def AsyncDialect : Dialect {
   let extraClassDeclaration = [{
     /// The name of a unit attribute on funcs that are allowed to have a
     /// blocking async.runtime.await ops. Only useful in combination with
     /// 'eliminate-blocking-await-ops' option, which in absence of this
     /// attribute might convert a func to a coroutine.
     static constexpr StringRef kAllowedToBlockAttrName =
         "async.allowed_to_block";
   }];
-
-  // TODO: Prefixed form overlaps with generated names, update before flipping.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 #endif // ASYNC_DIALECT_TD

mlir/include/mlir/Dialect/GPU/IR/GPUBase.td

let extraClassDeclaration = [{
     /// Returns the numeric value used to identify the private memory address
     /// space.
     static unsigned getPrivateAddressSpace() { return 5; }
   }];
 
   let dependentDialects = ["arith::ArithDialect"];
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
-
-  // TODO: Update this to _Prefixed.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 def GPU_AsyncToken : DialectType<
   GPU_Dialect, CPred<"$_self.isa<::mlir::gpu::AsyncTokenType>()">, "async token type">,
              BuildableType<"mlir::gpu::AsyncTokenType::get($_builder.getContext())">;
 
 // Predicat to check if type is gpu::MMAMatrixType.
 def IsMMAMatrixTypePred : CPred<"$_self.isa<::mlir::gpu::MMAMatrixType>()">;

mlir/include/mlir/Dialect/MemRef/IR/MemRefBase.td

def MemRef_Dialect : Dialect {
   let cppNamespace = "::mlir::memref";
   let description = [{
     The `memref` dialect is intended to hold core memref creation and
     manipulation ops, which are not strongly associated with any particular
     other dialect or domain abstraction.
   }];
   let dependentDialects = ["arith::ArithDialect"];
   let hasConstantMaterializer = 1;
-
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 #endif // MEMREF_BASE

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

def OpenACC_Dialect : Dialect {
   let summary = "An OpenACC dialect for MLIR.";
 
   let description = [{
     This dialect models the construct from the OpenACC 3.1 directive language.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let cppNamespace = "::mlir::acc";
-
-  // TODO: Flip to _Prefixed.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // AccCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenACC/AccCommon.td"
 
 // Base class for OpenACC dialect ops.
 class OpenACC_Op<string mnemonic, list<Trait> traits = []> :
   Op<OpenACC_Dialect, mnemonic, traits>;

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

 include "mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td"
 include "mlir/Dialect/OpenMP/OpenMPTypeInterfaces.td"
 
 def OpenMP_Dialect : Dialect {
   let name = "omp";
   let cppNamespace = "::mlir::omp";
   let dependentDialects = ["::mlir::LLVM::LLVMDialect"];
   let useDefaultAttributePrinterParser = 1;
-
-  // TODO: Flip to _Prefixed.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // OmpCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
 class OpenMP_Op<string mnemonic, list<Trait> traits = []> :
       Op<OpenMP_Dialect, mnemonic, traits>;
 

mlir/include/mlir/Dialect/PDL/IR/PDLDialect.td

def PDL_Dialect : Dialect {
 
   let name = "pdl";
   let cppNamespace = "::mlir::pdl";
 
   let useDefaultTypePrinterParser = 1;
   let extraClassDeclaration = [{
     void registerTypes();
   }];
-
-  // FIXME: Flip to prefixed.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLDIALECT

mlir/lib/Dialect/MemRef/Transforms/FoldMemRefAliasOps.cpp

LogicalResult LoadOpOfSubViewOpFolder<OpTy>::matchAndRewrite(
   }
   SmallVector<Value, 4> sourceIndices;
   if (failed(resolveSourceIndicesSubView(loadOp.getLoc(), rewriter, subViewOp,
                                          indices, sourceIndices)))
     return failure();
 
   llvm::TypeSwitch<Operation *, void>(loadOp)
       .Case<AffineLoadOp, memref::LoadOp>([&](auto op) {
-        rewriter.replaceOpWithNewOp<decltype(op)>(loadOp, subViewOp.source(),
+        rewriter.replaceOpWithNewOp<decltype(op)>(loadOp, subViewOp.getSource(),
                                                   sourceIndices);
       })
       .Case([&](vector::TransferReadOp transferReadOp) {
         rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
-            transferReadOp, transferReadOp.getVectorType(), subViewOp.source(),
-            sourceIndices,
+            transferReadOp, transferReadOp.getVectorType(),
+            subViewOp.getSource(), sourceIndices,
             getPermutationMapAttr(rewriter.getContext(), subViewOp,
                                   transferReadOp.getPermutationMap()),
             transferReadOp.getPadding(),
             /*mask=*/Value(), transferReadOp.getInBoundsAttr());
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
LogicalResult StoreOpOfSubViewOpFolder<OpTy>::matchAndRewrite(
   SmallVector<Value, 4> sourceIndices;
   if (failed(resolveSourceIndicesSubView(storeOp.getLoc(), rewriter, subViewOp,
                                          indices, sourceIndices)))
     return failure();
 
   llvm::TypeSwitch<Operation *, void>(storeOp)
       .Case<AffineStoreOp, memref::StoreOp>([&](auto op) {
         rewriter.replaceOpWithNewOp<decltype(op)>(
-            storeOp, storeOp.getValue(), subViewOp.source(), sourceIndices);
+            storeOp, storeOp.getValue(), subViewOp.getSource(), sourceIndices);
       })
       .Case([&](vector::TransferWriteOp op) {
         rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
-            op, op.getValue(), subViewOp.source(), sourceIndices,
+            op, op.getValue(), subViewOp.getSource(), sourceIndices,
             getPermutationMapAttr(rewriter.getContext(), subViewOp,
                                   op.getPermutationMap()),
             op.getInBoundsAttr());
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
 

mlir/lib/Dialect/MemRef/Transforms/SimplifyExtractStridedMetadata.cpp

class RewriteExtractAlignedPointerAsIndexOfViewLikeOp
   LogicalResult
   matchAndRewrite(memref::ExtractAlignedPointerAsIndexOp extractOp,
                   PatternRewriter &rewriter) const override {
     auto viewLikeOp =
         extractOp.getSource().getDefiningOp<ViewLikeOpInterface>();
     if (!viewLikeOp)
       return rewriter.notifyMatchFailure(extractOp, "not a ViewLike source");
     rewriter.updateRootInPlace(extractOp, [&]() {
-      extractOp.sourceMutable().assign(viewLikeOp.getViewSource());
+      extractOp.getSourceMutable().assign(viewLikeOp.getViewSource());
     });
     return success();
   }
 };
 } // namespace
 
 void memref::populateSimplifyExtractStridedMetadataOpPatterns(
     RewritePatternSet &patterns) {