build: fix deprecated mlir function

Author: gf712

src/executable/mlir/Conversion/PythonToPythonBytecode/FunctionPatterns.cpp

@@ -185,10 +185,10 @@ namespace {
 
 					if (mlir::isa<mlir::py::ConstantOp>(defining_op)) {
 						rewriter.setInsertionPoint(return_op);
-						auto class_cell =
-							rewriter.create<mlir::emitpybytecode::LoadClosureOp>(return_op.getLoc(),
-								mlir::py::PyObjectType::get(getContext()),
-								mlir::StringRef{ "__class__" });
+						auto class_cell = mlir::emitpybytecode::LoadClosureOp::create(rewriter,
+							return_op.getLoc(),
+							mlir::py::PyObjectType::get(getContext()),
+							mlir::StringRef{ "__class__" });
 						rewriter.modifyOpInPlace(
 							return_op, [&] { return_op.getValueMutable().assign(class_cell); });
 					} else {

src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp

@@ -56,54 +56,39 @@ namespace py {
 			return mlir::isa<TryOp, ForLoopOp, WithOp, WhileOp, TryHandlerOp>(op);
 		}
 
-		// True when `yield_op`, a loop-control (break/continue) yield, binds to the
-		// loop whose body region is `body`.
-		//
-		// Python binds break/continue to the innermost loop whose *body* lexically
-		// contains it. An else clause is not part of its own loop's body, so a yield
-		// sitting there keeps searching outwards — and transitively so: an else nested
-		// inside another else is still lexically part of whatever body encloses the
-		// pair. Regions that are neither body nor orelse (a try body, a with body) are
-		// likewise transparent, which is what makes `break` inside a `try` bind to the
-		// loop around it.
-		bool binds_to_loop(mlir::Region &body, mlir::py::BranchYieldOp yield_op)
+		// True when `yield_op` is a loop-control (break/continue) yield that binds to
+		// the loop *enclosing* `loop` rather than to `loop` itself — i.e. it sits in
+		// `loop`'s orelse, which is not part of the loop body.
+		bool binds_to_enclosing_loop(mlir::py::PyLoopOpInterface loop,
+			mlir::py::BranchYieldOp yield_op)
 		{
-			for (mlir::Region *region = yield_op->getParentRegion(); region != nullptr;
-				region = region->getParentRegion()) {
-				if (region == &body) { return true; }
-				auto loop =
-					mlir::dyn_cast_if_present<mlir::py::PyLoopOpInterface>(region->getParentOp());
-				// A loop body (or a for's step) stops the search: the yield is that
-				// loop's, and its own pattern claims it.
-				if (loop && !loop.isLoopOrelse(region)) { return false; }
-			}
-			return false;
+			return yield_op.getKind().has_value() && loop.isLoopOrelse(yield_op->getParentRegion());
 		}
 
-		// True when a break/continue that binds to the loop whose body is `body` is
-		// somewhere replace_loop_branch_yields cannot reach yet — inside a nested
-		// region that has not been flattened into ours. Branching it to our target
-		// block now would be a cross-region block reference, which is invalid IR.
+		// True when some loop nested in `region` still holds a break/continue that
+		// binds to the loop being lowered — i.e. one sitting in that nested loop's
+		// orelse. Such a yield cannot be rewritten yet: it lives in a region that has
+		// not been flattened, so branching it to our target block would be a
+		// cross-region block reference, which is invalid IR.
 		//
-		// The caller defers (fails the match) until the nested op lowers and inlines
+		// The caller defers (fails the match) until the nested loop lowers and inlines
 		// the yield into our region, the same innermost-first trick TryOpLowering uses
-		// for nested trys. Terminates because the innermost such op has nothing nested
-		// to wait on.
-		bool has_pending_nested_orelse_control(mlir::Region &body)
+		// for nested trys. Terminates because the innermost such loop has nothing
+		// nested to wait on.
+		bool has_pending_nested_orelse_control(mlir::Region &region)
 		{
-			if (body.empty()) { return false; }
+			if (region.empty()) { return false; }
 			bool pending = false;
-			body.walk<WalkOrder::PreOrder>([&pending, &body](mlir::Operation *op) {
-				// Mirror replace_loop_branch_yields: what it walks through it rewrites
-				// in place, so only what it skips over can be pending.
-				if (!is_flattened_region_op(op)) { return WalkResult::advance(); }
-				op->walk([&pending, &body](mlir::py::BranchYieldOp yield_op) {
-					if (!yield_op.getKind().has_value()) { return WalkResult::advance(); }
-					if (!binds_to_loop(body, yield_op)) { return WalkResult::advance(); }
-					pending = true;
-					return WalkResult::interrupt();
-				});
-				return pending ? WalkResult::interrupt() : WalkResult::skip();
+			region.walk<WalkOrder::PreOrder>([&pending](mlir::Operation *op) {
+				auto loop = mlir::dyn_cast<mlir::py::PyLoopOpInterface>(op);
+				if (!loop) { return WalkResult::advance(); }
+				loop.getLoopOrelseRegion().walk<WalkOrder::PreOrder>(
+					[&pending, loop](mlir::py::BranchYieldOp yield_op) {
+						if (binds_to_enclosing_loop(loop, yield_op)) { pending = true; }
+					});
+				// Only this loop's own orelse matters here; anything deeper is the
+				// nested loop's problem and it defers on it in turn.
+				return WalkResult::skip();
 			});
 			return pending;
 		}
@@ -348,8 +333,8 @@ namespace py {
 				mlir::cf::BranchOp::create(rewriter, condition_op.getLoc(), &condition_start);
 
 				rewriter.setInsertionPoint(condition_op);
-				auto should_jump = rewriter.create<mlir::py::CastToBoolOp>(
-					condition_op.getLoc(), rewriter.getI1Type(), condition_op.getCond());
+				auto should_jump = mlir::py::CastToBoolOp::create(
+					rewriter, condition_op.getLoc(), rewriter.getI1Type(), condition_op.getCond());
 				ASSERT(!op.getBody().empty());
 				mlir::cf::CondBranchOp::create(rewriter,
 					condition_op.getLoc(),
@@ -759,9 +744,9 @@ namespace py {
 							auto *current = y->getBlock();
 							auto *next = rewriter.splitBlock(current, y->getIterator());
 							rewriter.setInsertionPointToEnd(current);
-							rewriter.create<mlir::emitpybytecode::LeaveExceptionHandle>(
-								y->getLoc());
-							rewriter.create<mlir::cf::BranchOp>(y->getLoc(), exit_block);
+							mlir::emitpybytecode::LeaveExceptionHandle::create(
+								rewriter, y->getLoc());
+							mlir::cf::BranchOp::create(rewriter, y->getLoc(), exit_block);
 							rewriter.eraseBlock(next);
 						} else if (auto y = mlir::dyn_cast<mlir::py::BranchYieldOp>(childOp);
 							y && y.getKind().has_value()) {
@@ -772,12 +757,12 @@ namespace py {
 							auto *next = rewriter.splitBlock(current, y->getIterator());
 							auto *lc_block = rewriter.createBlock(endBlock);
 							rewriter.setInsertionPointToEnd(current);
-							rewriter.create<mlir::emitpybytecode::LeaveExceptionHandle>(
-								y->getLoc());
-							rewriter.create<mlir::cf::BranchOp>(y->getLoc(), lc_block);
+							mlir::emitpybytecode::LeaveExceptionHandle::create(
+								rewriter, y->getLoc());
+							mlir::cf::BranchOp::create(rewriter, y->getLoc(), lc_block);
 							rewriter.setInsertionPointToStart(lc_block);
 							emit_normal_exit();
-							rewriter.create<mlir::py::BranchYieldOp>(y->getLoc(), y.getKindAttr());
+							mlir::py::BranchYieldOp::create(rewriter, y->getLoc(), y.getKindAttr());
 							rewriter.eraseBlock(next);
 						}
 						return WalkResult::advance();

src/executable/mlir/Dialect/Python/IR/Ops.cpp

@@ -406,7 +406,7 @@ namespace py {
 		return region_or_block_arguments(getOperation(), successor);
 	}
 
-	void BranchYieldOp::getSuccessorRegions(llvm::ArrayRef<mlir::Attribute> operands,
+	void BranchYieldOp::getSuccessorRegions(llvm::ArrayRef<mlir::Attribute> /*operands*/,
 		llvm::SmallVectorImpl<mlir::RegionSuccessor> &regions)
 	{
 		static_assert(BranchYieldOp::hasTrait<