[flang][NFC] add builder to simplify fir.shape creation

[jeanPerier]

Summary

Depends on D140023

[clementval]

LGTM

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Lower/ConvertExpr.cpp

7275

When I run clang-format on this line, I get the following:

if (const Fortran::semantics::Symbol * symbol{GetLastSymbol(expr)}) {

Note the space between the "*" and "symbol".

[jeanPerier]

Revert unrelated formatting change.

[jeanPerier]

flang/lib/Lower/ConvertExpr.cpp

7275

Thanks, I reverted that change.

flang/include/flang/Optimizer/Dialect/FIROps.td

def fir_ShapeOp : fir_Op<"shape", [NoMemoryEffect]> {
 
   let results = (outs fir_ShapeType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
+
+  let builders = [OpBuilder<(ins "mlir::ValueRange":$extents)>];
 }
 
 def fir_ShapeShiftOp : fir_Op<"shape_shift", [NoMemoryEffect]> {
 
   let summary = [{
     generate an abstract shape and shift vector of type `!fir.shapeshift`
   }];
 

flang/lib/Lower/ConvertExpr.cpp

private:
   }
 
   static fir::ShapeOp genShapeOp(mlir::Location loc, fir::FirOpBuilder &builder,
                                  llvm::ArrayRef<mlir::Value> shape) {
     mlir::IndexType idxTy = builder.getIndexType();
     llvm::SmallVector<mlir::Value> idxShape;
     for (auto s : shape)
       idxShape.push_back(builder.createConvert(loc, idxTy, s));
-    auto shapeTy = fir::ShapeType::get(builder.getContext(), idxShape.size());
-    return builder.create<fir::ShapeOp>(loc, shapeTy, idxShape);
+    return builder.create<fir::ShapeOp>(loc, idxShape);
   }
 
   fir::ShapeOp genShapeOp(llvm::ArrayRef<mlir::Value> shape) {
     return genShapeOp(getLoc(), builder, shape);
   }
 
   //===--------------------------------------------------------------------===//
   // Expression traversal and lowering.
fir::MutableBoxValue Fortran::lower::createMutableBox(
   // resulting MutableBoxValue. Variables of all other types are handled in the
   // bridge.
   Fortran::lower::StatementContext dummyStmtCtx;
   return ScalarExprLowering{loc, converter, symMap, dummyStmtCtx}
       .genMutableBoxValue(expr);
 }
 
 bool isParentComponent(const Fortran::lower::SomeExpr &expr) {
   if (const Fortran::semantics::Symbol * symbol{GetLastSymbol(expr)}) {
     if (symbol->test(Fortran::semantics::Symbol::Flag::ParentComp))
       return true;
   }
   return false;
 }
 
 template <typename OP>
 mlir::Value createSliceForParentComp(fir::FirOpBuilder &builder,

flang/lib/Optimizer/Builder/FIRBuilder.cpp

fir::StringLitOp fir::FirOpBuilder::createStringLitOp(mlir::Location loc,
   mlir::NamedAttribute sizeAttr(sizeTag, getI64IntegerAttr(data.size()));
   llvm::SmallVector<mlir::NamedAttribute> attrs{dataAttr, sizeAttr};
   return create<fir::StringLitOp>(loc, llvm::ArrayRef<mlir::Type>{type},
                                   std::nullopt, attrs);
 }
 
 mlir::Value fir::FirOpBuilder::genShape(mlir::Location loc,
                                         llvm::ArrayRef<mlir::Value> exts) {
-  auto shapeType = fir::ShapeType::get(getContext(), exts.size());
-  return create<fir::ShapeOp>(loc, shapeType, exts);
+  return create<fir::ShapeOp>(loc, exts);
 }
 
 mlir::Value fir::FirOpBuilder::genShape(mlir::Location loc,
                                         llvm::ArrayRef<mlir::Value> shift,
                                         llvm::ArrayRef<mlir::Value> exts) {
   auto shapeType = fir::ShapeShiftType::get(getContext(), exts.size());
   llvm::SmallVector<mlir::Value> shapeArgs;
   auto idxTy = getIndexType();

flang/lib/Optimizer/Builder/MutableBox.cpp

createNewFirBox(fir::FirOpBuilder &builder, mlir::Location loc,
                 mlir::ValueRange lengths, mlir::Value tdesc = {}) {
   if (addr.getType().isa<fir::BaseBoxType>())
     // The entity is already boxed.
     return builder.createConvert(loc, box.getBoxTy(), addr);
 
   mlir::Value shape;
   if (!extents.empty()) {
     if (lbounds.empty()) {
-      auto shapeType =
-          fir::ShapeType::get(builder.getContext(), extents.size());
-      shape = builder.create<fir::ShapeOp>(loc, shapeType, extents);
+      shape = builder.create<fir::ShapeOp>(loc, extents);
     } else {
       llvm::SmallVector<mlir::Value> shapeShiftBounds;
       for (auto [lb, extent] : llvm::zip(lbounds, extents)) {
         shapeShiftBounds.emplace_back(lb);
         shapeShiftBounds.emplace_back(extent);
       }
       auto shapeShiftType =
           fir::ShapeShiftType::get(builder.getContext(), extents.size());

flang/lib/Optimizer/Dialect/FIROps.cpp

mlir::LogicalResult fir::ShapeOp::verify() {
   auto size = getExtents().size();
   auto shapeTy = getType().dyn_cast<fir::ShapeType>();
   assert(shapeTy && "must be a shape type");
   if (shapeTy.getRank() != size)
     return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
+void fir::ShapeOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
+                         mlir::ValueRange extents) {
+  auto type = fir::ShapeType::get(builder.getContext(), extents.size());
+  build(builder, result, type, extents);
+}
+
 //===----------------------------------------------------------------------===//
 // ShapeShiftOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult fir::ShapeShiftOp::verify() {
   auto size = getPairs().size();
   if (size < 2 || size > 16 * 2)
     return emitOpError("incorrect number of args");

flang/unittests/Optimizer/FortranVariableTest.cpp

public:
   mlir::Location getLoc() { return builder->getUnknownLoc(); }
   mlir::Value createConstant(std::int64_t cst) {
     mlir::Type indexType = builder->getIndexType();
     return builder->create<mlir::arith::ConstantOp>(
         getLoc(), indexType, builder->getIntegerAttr(indexType, cst));
   }
 
   mlir::Value createShape(llvm::ArrayRef<mlir::Value> extents) {
-    mlir::Type shapeType = fir::ShapeType::get(&context, extents.size());
-    return builder->create<fir::ShapeOp>(getLoc(), shapeType, extents);
+    return builder->create<fir::ShapeOp>(getLoc(), extents);
   }
   mlir::MLIRContext context;
   std::unique_ptr<mlir::OpBuilder> builder;
 };
 
 TEST_F(FortranVariableTest, SimpleScalar) {
   mlir::Location loc = getLoc();
   mlir::Type eleType = mlir::FloatType::getF32(&context);