[mlir] Remove EDSC LoopBuilder, derived classes and related functionality

[ftynse]

Summary

Callback-based loop construction, with loop bodies being constructed during the
construction of the parent op using a function, is now fully supported by the
core infrastructure. This provides almost the same level of brevity as EDSC
LoopBuilder at less than 30% infrastructural code cost. Functional equivalents
compatible with EDSC ScopedContext are implemented on top of the main builders.
LoopBuilder and related functionality has been deprecated, remove it.

Depends On D81873

[rriddle]

Awesome!!

[nicolasvasilache]

Thanks Alex !

[mehdi_amini]

Nice to see the progress here :)

[ftynse]

Rebase

[ftynse]

Rebase

mlir/include/mlir/Dialect/Affine/EDSC/Builders.h

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
 namespace edsc {
 
-/// Constructs a new AffineForOp and captures the associated induction
-/// variable. A Value pointer is passed as the first argument and is the
-/// *only* way to capture the loop induction variable.
-LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
-                                  ArrayRef<Value> ubs, int64_t step);
-
-/// Deprecated. Use affineLoopNestBuilder instead.
-///
-/// Explicit nested LoopBuilder. Offers a compressed multi-loop builder to avoid
-/// explicitly writing all the loops in a nest. This simple functionality is
-/// also useful to write rank-agnostic custom ops.
-///
-/// Usage:
-///
-/// ```c++
-///    AffineLoopNestBuilder({&i, &j, &k}, {lb, lb, lb}, {ub, ub, ub}, {1, 1,
-///    1})(
-///      [&](){
-///        ...
-///      });
-/// ```
-///
-/// ```c++
-///    AffineLoopNestBuilder({&i}, {lb}, {ub}, {1})([&](){
-///      AffineLoopNestBuilder({&j}, {lb}, {ub}, {1})([&](){
-///        AffineLoopNestBuilder({&k}, {lb}, {ub}, {1})([&](){
-///          ...
-///        }),
-///      }),
-///    });
-/// ```
-class AffineLoopNestBuilder {
-public:
-  /// This entry point accommodates the fact that AffineForOp implicitly uses
-  /// multiple `lbs` and `ubs` with one single `iv` and `step` to encode `max`
-  /// and and `min` constraints respectively.
-  AffineLoopNestBuilder(Value *iv, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
-                        int64_t step);
-  AffineLoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
-                        ArrayRef<Value> ubs, ArrayRef<int64_t> steps);
-
-  void operator()(function_ref<void(void)> fun = nullptr);
-
-private:
-  SmallVector<LoopBuilder, 4> loops;
-};
-
 /// Creates a perfect nest of affine "for" loops, given the list of lower
 /// bounds, upper bounds and steps. The three lists are expected to contain the
 /// same number of elements. Uses the OpBuilder and Location stored in
 /// ScopedContext and assumes they are non-null. The optional "bodyBuilderFn"
 /// callback is called to construct the body of the innermost loop and is passed
 /// the list of loop induction variables, in order from outermost to innermost.
 /// The function is expected to use the builder and location stored in
 /// ScopedContext at the moment of the call. The function should not create

mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h

 //===- Builders.h - MLIR Declarative Linalg Builders ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides intuitive composable interfaces for building structured MLIR
 // snippets in a declarative fashion.
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 #define MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
-// TODO(ntv): Needed for SubViewOp::Range, clean this up.
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 
 namespace mlir {
 class AffineForOp;
 class BlockArgument;
-class SubViewOp;
 
 namespace scf {
 class ParallelOp;
 } // namespace scf
 
 namespace edsc {
-class AffineLoopNestBuilder;
-class LoopNestBuilder;
-class ParallelLoopNestBuilder;
-
-/// Helper template class for building scf.for and affine.loop nests from
-/// ranges.
-template <typename LoopTy> class GenericLoopNestRangeBuilder {
-public:
-  GenericLoopNestRangeBuilder(MutableArrayRef<Value> ivs,
-                              ArrayRef<SubViewOp::Range> ranges);
-  void operator()(std::function<void(void)> fun = nullptr) { (*builder)(fun); }
-
-private:
-  using LoopOrAffineLoopBuilder =
-      typename std::conditional_t<std::is_same<LoopTy, AffineForOp>::value,
-                                  AffineLoopNestBuilder, LoopNestBuilder>;
-  using BuilderType =
-      typename std::conditional_t<std::is_same<LoopTy, scf::ParallelOp>::value,
-                                  ParallelLoopNestBuilder,
-                                  LoopOrAffineLoopBuilder>;
-
-  std::unique_ptr<BuilderType> builder;
-};
-
 inline void defaultRegionBuilder(ValueRange args) {}
 
 /// Build a `linalg.generic` op with the specified `inputs`, `outputs` and
 /// `region`.
 ///
 /// `otherValues` and `otherAttributes` may be passed and will be appended as
 /// operands and attributes respectively.
 ///

mlir/include/mlir/Dialect/SCF/EDSC/Builders.h

 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
 namespace edsc {
 
-/// Constructs a new scf::ParallelOp and captures the associated induction
-/// variables. An array of Value pointers is passed as the first
-/// argument and is the *only* way to capture loop induction variables.
-LoopBuilder makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
-                                    ArrayRef<Value> lbs, ArrayRef<Value> ubs,
-                                    ArrayRef<Value> steps);
-/// Constructs a new scf::ForOp and captures the associated induction
-/// variable. A Value pointer is passed as the first argument and is the
-/// *only* way to capture the loop induction variable.
-LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
-                            MutableArrayRef<Value> iterArgsHandles,
-                            ValueRange iterArgsInitValues);
-LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
-                            MutableArrayRef<Value> iterArgsHandles,
-                            ValueRange iterArgsInitValues);
-inline LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step) {
-  return makeLoopBuilder(iv, lb, ub, step, MutableArrayRef<Value>{}, {});
-}
-
-/// Helper class to sugar building scf.parallel loop nests from lower/upper
-/// bounds and step sizes.
-class ParallelLoopNestBuilder {
-public:
-  ParallelLoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
-                          ArrayRef<Value> ubs, ArrayRef<Value> steps);
-
-  void operator()(function_ref<void(void)> fun = nullptr);
-
-private:
-  SmallVector<LoopBuilder, 4> loops;
-};
-
-/// Helper class to sugar building scf.for loop nests from ranges.
-/// This is similar to edsc::AffineLoopNestBuilder except it operates on
-/// scf.for.
-class LoopNestBuilder {
-public:
-  LoopNestBuilder(Value *iv, Value lb, Value ub, Value step);
-  LoopNestBuilder(Value *iv, Value lb, Value ub, Value step,
-                  MutableArrayRef<Value> iterArgsHandles,
-                  ValueRange iterArgsInitValues);
-  LoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
-                  ArrayRef<Value> ubs, ArrayRef<Value> steps);
-  ValueRange operator()(std::function<void(void)> fun = nullptr);
-
-private:
-  SmallVector<LoopBuilder, 4> loops;
-};
-
 /// Adapters for building loop nests using the builder and the location stored
 /// in ScopedContext. Actual builders are in scf::buildLoopNest.
 scf::ValueVector loopNestBuilder(ValueRange lbs, ValueRange ubs,
                                  ValueRange steps,
                                  function_ref<void(ValueRange)> fun = nullptr);
 scf::ValueVector loopNestBuilder(Value lb, Value ub, Value step,
                                  function_ref<void(Value)> fun = nullptr);
 scf::ValueVector loopNestBuilder(

mlir/include/mlir/EDSC/Builders.h

~NestedBuilder() {
     assert(!bodyScope &&
            "Illegal use of NestedBuilder; must have called exit()");
   }
 
 private:
   ScopedContext *bodyScope = nullptr;
 };
 
-/// A LoopBuilder is a generic NestedBuilder for loop-like MLIR operations.
-/// More specifically it is meant to be used as a temporary object for
-/// representing any nested MLIR construct that is "related to" an mlir::Value
-/// (for now an induction variable).
-/// This is extensible and will evolve in the future as MLIR evolves, hence
-/// the name LoopBuilder (as opposed to say ForBuilder or AffineForBuilder).
-class LoopBuilder : public NestedBuilder {
-public:
-  LoopBuilder(const LoopBuilder &) = delete;
-  LoopBuilder(LoopBuilder &&) = default;
-
-  LoopBuilder &operator=(const LoopBuilder &) = delete;
-  LoopBuilder &operator=(LoopBuilder &&) = default;
-
-  /// The only purpose of this operator is to serve as a sequence point so that
-  /// the evaluation of `fun` (which build IR snippets in a scoped fashion) is
-  /// scoped within a LoopBuilder.
-  void operator()(function_ref<void(void)> fun = nullptr);
-  void setOp(Operation *op) { this->op = op; }
-  Operation *getOp() { return op; }
-
-private:
-  LoopBuilder() = default;
-
-  friend LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
-                                           ArrayRef<Value> ubs, int64_t step);
-  friend LoopBuilder makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
-                                             ArrayRef<Value> lbs,
-                                             ArrayRef<Value> ubs,
-                                             ArrayRef<Value> steps);
-  friend LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
-                                     MutableArrayRef<Value> iterArgsHandles,
-                                     ValueRange iterArgsInitValues);
-  Operation *op;
-};
-
 // This class exists solely to handle the C++ vexing parse case when
 // trying to enter a Block that has already been constructed.
 class Append {};
 
 /// Deprecated. Use buildInNewBlock or appendToBlock instead.
 ///
 /// A BlockBuilder is a NestedBuilder for mlir::Block*.
 /// This exists by opposition to LoopBuilder which is not related to an

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

 //===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
-static Optional<Value> emitStaticFor(ArrayRef<Value> lbs, ArrayRef<Value> ubs,
-                                     int64_t step) {
-  if (lbs.size() != 1 || ubs.size() != 1)
-    return Optional<Value>();
-
-  auto *lbDef = lbs.front().getDefiningOp();
-  auto *ubDef = ubs.front().getDefiningOp();
-  if (!lbDef || !ubDef)
-    return Optional<Value>();
-
-  auto lbConst = dyn_cast<ConstantIndexOp>(lbDef);
-  auto ubConst = dyn_cast<ConstantIndexOp>(ubDef);
-  if (!lbConst || !ubConst)
-    return Optional<Value>();
-  return ScopedContext::getBuilderRef()
-      .create<AffineForOp>(ScopedContext::getLocation(), lbConst.getValue(),
-                           ubConst.getValue(), step)
-      .getInductionVar();
-}
-
-LoopBuilder mlir::edsc::makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
-                                              ArrayRef<Value> ubs,
-                                              int64_t step) {
-  mlir::edsc::LoopBuilder result;
-  if (auto staticForIv = emitStaticFor(lbs, ubs, step))
-    *iv = staticForIv.getValue();
-  else
-    *iv = ScopedContext::getBuilderRef()
-              .create<AffineForOp>(
-                  ScopedContext::getLocation(), lbs,
-                  ScopedContext::getBuilderRef().getMultiDimIdentityMap(
-                      lbs.size()),
-                  ubs,
-                  ScopedContext::getBuilderRef().getMultiDimIdentityMap(
-                      ubs.size()),
-                  step)
-              .getInductionVar();
-
-  auto *body = getForInductionVarOwner(*iv).getBody();
-  result.enter(body);
-  return result;
-}
-
-mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(Value *iv,
-                                                         ArrayRef<Value> lbs,
-                                                         ArrayRef<Value> ubs,
-                                                         int64_t step) {
-  loops.emplace_back(makeAffineLoopBuilder(iv, lbs, ubs, step));
-}
-
 void mlir::edsc::affineLoopNestBuilder(
     ValueRange lbs, ValueRange ubs, ArrayRef<int64_t> steps,
     function_ref<void(ValueRange)> bodyBuilderFn) {
   assert(ScopedContext::getContext() && "EDSC ScopedContext not set up");
 
   // Wrap the body builder function into an interface compatible with the main
   // builder.
   auto wrappedBuilderFn = [&](OpBuilder &nestedBuilder, Location nestedLoc,
builder.create<AffineForOp>(
           ScopedContext nestedContext(nestedBuilder, nestedLoc);
           OpBuilder::InsertionGuard guard(nestedBuilder);
           bodyBuilderFn(iv);
         }
         nestedBuilder.create<AffineTerminatorOp>(nestedLoc);
       });
 }
 
-mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
-    MutableArrayRef<Value> ivs, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
-    ArrayRef<int64_t> steps) {
-  assert(ivs.size() == lbs.size() && "Mismatch in number of arguments");
-  assert(ivs.size() == ubs.size() && "Mismatch in number of arguments");
-  assert(ivs.size() == steps.size() && "Mismatch in number of arguments");
-  for (auto it : llvm::zip(ivs, lbs, ubs, steps))
-    loops.emplace_back(makeAffineLoopBuilder(&std::get<0>(it), std::get<1>(it),
-                                             std::get<2>(it), std::get<3>(it)));
-}
-
-void mlir::edsc::AffineLoopNestBuilder::operator()(
-    function_ref<void(void)> fun) {
-  if (fun)
-    fun();
-  // Iterate on the calling operator() on all the loops in the nest.
-  // The iteration order is from innermost to outermost because enter/exit needs
-  // to be asymmetric (i.e. enter() occurs on LoopBuilder construction, exit()
-  // occurs on calling operator()). The asymmetry is required for properly
-  // nesting imperfectly nested regions (see LoopBuilder::operator()).
-  for (auto lit = loops.rbegin(), eit = loops.rend(); lit != eit; ++lit)
-    (*lit)();
-}
-
 static std::pair<AffineExpr, Value>
 categorizeValueByAffineType(MLIRContext *context, Value val, unsigned &numDims,
                             unsigned &numSymbols) {
   AffineExpr d;
   Value resultVal = nullptr;
   if (auto constant = val.getDefiningOp<ConstantIndexOp>()) {
     d = getAffineConstantExpr(constant.getValue(), context);
   } else if (isValidSymbol(val) && !isValidDim(val)) {

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

 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
-static void unpackRanges(ArrayRef<SubViewOp::Range> ranges,
-                         SmallVectorImpl<Value> &lbs,
-                         SmallVectorImpl<Value> &ubs,
-                         SmallVectorImpl<Value> &steps) {
-  for (SubViewOp::Range range : ranges) {
-    lbs.emplace_back(range.offset);
-    ubs.emplace_back(range.size);
-    steps.emplace_back(range.stride);
-  }
-}
-
-namespace mlir {
-namespace edsc {
-
-template <>
-GenericLoopNestRangeBuilder<scf::ForOp>::GenericLoopNestRangeBuilder(
-    MutableArrayRef<Value> ivs, ArrayRef<SubViewOp::Range> ranges) {
-  SmallVector<Value, 4> lbs, ubs, steps;
-  unpackRanges(ranges, lbs, ubs, steps);
-  builder = std::make_unique<LoopNestBuilder>(ivs, lbs, ubs, steps);
-}
-
-template <>
-GenericLoopNestRangeBuilder<AffineForOp>::GenericLoopNestRangeBuilder(
-    MutableArrayRef<Value> ivs, ArrayRef<SubViewOp::Range> ranges) {
-  SmallVector<Value, 4> lbs, ubs, steps;
-  unpackRanges(ranges, lbs, ubs, steps);
-  SmallVector<int64_t, 4> constantSteps;
-  constantSteps.reserve(steps.size());
-  for (Value v : steps) {
-    auto op = v.getDefiningOp<ConstantIndexOp>();
-    assert(op && "Affine loops require constant steps");
-    constantSteps.push_back(op.getValue());
-  }
-  builder =
-      std::make_unique<AffineLoopNestBuilder>(ivs, lbs, ubs, constantSteps);
-}
-
-template <>
-GenericLoopNestRangeBuilder<scf::ParallelOp>::GenericLoopNestRangeBuilder(
-    MutableArrayRef<Value> ivs, ArrayRef<SubViewOp::Range> ranges) {
-  SmallVector<Value, 4> lbs, ubs, steps;
-  unpackRanges(ranges, lbs, ubs, steps);
-  builder = std::make_unique<ParallelLoopNestBuilder>(ivs, lbs, ubs, steps);
-}
-
-} // namespace edsc
-} // namespace mlir
-
 Operation *mlir::edsc::makeGenericLinalgOp(
     ArrayRef<IteratorType> iteratorTypes, ArrayRef<StructuredIndexed> inputs,
     ArrayRef<StructuredIndexed> outputs,
     function_ref<void(ValueRange)> regionBuilder, ArrayRef<Value> otherValues,
     ArrayRef<Attribute> otherAttributes) {
   for (unsigned i = 0, e = outputs.size(); i + 1 < e; ++i)
     assert(!(outputs[i].getType().isa<RankedTensorType>() &&
              outputs[i + 1].getType().isa<MemRefType>()) &&

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

 //===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SCF/EDSC/Builders.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
-mlir::edsc::ParallelLoopNestBuilder::ParallelLoopNestBuilder(
-    MutableArrayRef<Value> ivs, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
-    ArrayRef<Value> steps) {
-  assert(ivs.size() == lbs.size() && "Mismatch in number of arguments");
-  assert(ivs.size() == ubs.size() && "Mismatch in number of arguments");
-  assert(ivs.size() == steps.size() && "Mismatch in number of arguments");
-
-  loops.emplace_back(makeParallelLoopBuilder(ivs, lbs, ubs, steps));
-}
-
-void mlir::edsc::ParallelLoopNestBuilder::operator()(
-    function_ref<void(void)> fun) {
-  if (fun)
-    fun();
-  // Iterate on the calling operator() on all the loops in the nest.
-  // The iteration order is from innermost to outermost because enter/exit needs
-  // to be asymmetric (i.e. enter() occurs on LoopBuilder construction, exit()
-  // occurs on calling operator()). The asymmetry is required for properly
-  // nesting imperfectly nested regions (see LoopBuilder::operator()).
-  for (auto lit = loops.rbegin(), eit = loops.rend(); lit != eit; ++lit)
-    (*lit)();
-}
-
-mlir::edsc::LoopNestBuilder::LoopNestBuilder(MutableArrayRef<Value> ivs,
-                                             ArrayRef<Value> lbs,
-                                             ArrayRef<Value> ubs,
-                                             ArrayRef<Value> steps) {
-  assert(ivs.size() == lbs.size() && "expected size of ivs and lbs to match");
-  assert(ivs.size() == ubs.size() && "expected size of ivs and ubs to match");
-  assert(ivs.size() == steps.size() &&
-         "expected size of ivs and steps to match");
-  loops.reserve(ivs.size());
-  for (auto it : llvm::zip(ivs, lbs, ubs, steps))
-    loops.emplace_back(makeLoopBuilder(&std::get<0>(it), std::get<1>(it),
-                                       std::get<2>(it), std::get<3>(it)));
-  assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
-}
-
-mlir::edsc::LoopNestBuilder::LoopNestBuilder(
-    Value *iv, Value lb, Value ub, Value step,
-    MutableArrayRef<Value> iterArgsHandles, ValueRange iterArgsInitValues) {
-  assert(iterArgsInitValues.size() == iterArgsHandles.size() &&
-         "expected size of arguments and argument_handles to match");
-  loops.emplace_back(
-      makeLoopBuilder(iv, lb, ub, step, iterArgsHandles, iterArgsInitValues));
-}
-
-mlir::edsc::LoopNestBuilder::LoopNestBuilder(Value *iv, Value lb, Value ub,
-                                             Value step) {
-  SmallVector<Value, 0> noArgs;
-  loops.emplace_back(makeLoopBuilder(iv, lb, ub, step, noArgs, {}));
-}
-
-ValueRange mlir::edsc::LoopNestBuilder::LoopNestBuilder::operator()(
-    std::function<void(void)> fun) {
-  if (fun)
-    fun();
-
-  for (auto &lit : reverse(loops))
-    lit({});
-
-  if (!loops.empty())
-    return loops[0].getOp()->getResults();
-  return {};
-}
-
-LoopBuilder mlir::edsc::makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
-                                                ArrayRef<Value> lbs,
-                                                ArrayRef<Value> ubs,
-                                                ArrayRef<Value> steps) {
-  scf::ParallelOp parallelOp = OperationBuilder<scf::ParallelOp>(
-      SmallVector<Value, 4>(lbs.begin(), lbs.end()),
-      SmallVector<Value, 4>(ubs.begin(), ubs.end()),
-      SmallVector<Value, 4>(steps.begin(), steps.end()));
-  for (size_t i = 0, e = ivs.size(); i < e; ++i)
-    ivs[i] = parallelOp.getBody()->getArgument(i);
-  LoopBuilder result;
-  result.enter(parallelOp.getBody());
-  return result;
-}
-
-mlir::edsc::LoopBuilder
-mlir::edsc::makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
-                            MutableArrayRef<Value> iterArgsHandles,
-                            ValueRange iterArgsInitValues) {
-  mlir::edsc::LoopBuilder result;
-  scf::ForOp forOp =
-      OperationBuilder<scf::ForOp>(lb, ub, step, iterArgsInitValues);
-  *iv = Value(forOp.getInductionVar());
-  auto *body = scf::getForInductionVarOwner(*iv).getBody();
-  for (size_t i = 0, e = iterArgsHandles.size(); i < e; ++i) {
-    // Skipping the induction variable.
-    iterArgsHandles[i] = body->getArgument(i + 1);
-  }
-  result.setOp(forOp);
-  result.enter(body);
-  return result;
-}
-
 mlir::scf::ValueVector
 mlir::edsc::loopNestBuilder(ValueRange lbs, ValueRange ubs, ValueRange steps,
                             function_ref<void(ValueRange)> fun) {
   // Delegates actual construction to scf::buildLoopNest by wrapping `fun` into
   // the expected function interface.
   assert(ScopedContext::getContext() && "EDSC ScopedContext not set up");
   return mlir::scf::buildLoopNest(
       ScopedContext::getBuilderRef(), ScopedContext::getLocation(), lbs, ubs,

mlir/lib/EDSC/Builders.cpp

Block *mlir::edsc::buildInNewBlock(Region &region, TypeRange argTypes,
 
   Block *block = createBlockInRegion(region, argTypes);
   OpBuilder::InsertionGuard guard(builder);
   builder.setInsertionPointToStart(block);
   builderFn(block->getArguments());
   return block;
 }
 
-void mlir::edsc::LoopBuilder::operator()(function_ref<void(void)> fun) {
-  // Call to `exit` must be explicit and asymmetric (cannot happen in the
-  // destructor) because of ordering wrt comma operator.
-  /// The particular use case concerns nested blocks:
-  ///
-  /// ```c++
-  ///    For (&i, lb, ub, 1)({
-  ///      /--- destructor for this `For` is not always called before ...
-  ///      V
-  ///      For (&j1, lb, ub, 1)({
-  ///        some_op_1,
-  ///      }),
-  ///      /--- ... this scope is entered, resulting in improperly nested IR.
-  ///      V
-  ///      For (&j2, lb, ub, 1)({
-  ///        some_op_2,
-  ///      }),
-  ///    });
-  /// ```
-  if (fun)
-    fun();
-  exit();
-}
-
 mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle bh, Append) {
   assert(bh && "Expected already captured BlockHandle");
   enter(bh.getBlock());
 }
 
 mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle *bh, ArrayRef<Type> types,
                                        MutableArrayRef<Value> args) {
   assert(!*bh && "BlockHandle already captures a block, use "