[flang] fix unused-but-set-parameter warning in ConvertExprToHLFIR.cpp

[jeanPerier]

Summary

Some named value operands are not used yet (TODOs). Some compilers
complain about it. Remove names of unused parameters.

[PeteSteinfeld]

All builds and tests correctly and looks good. Thanks for fixing this!

flang/lib/Lower/ConvertExprToHLFIR.cpp

 GENBIN(Divide, Integer, mlir::arith::DivSIOp)
 GENBIN(Divide, Real, mlir::arith::DivFOp)
 GENBIN(Divide, Complex, fir::DivcOp)
 
 template <Fortran::common::TypeCategory TC, int KIND>
 struct BinaryOp<Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>>> {
   using Op = Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs,
-                                         hlfir::Entity rhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs, hlfir::Entity rhs) {
     mlir::Type ty = Fortran::lower::getFIRType(builder.getContext(), TC, KIND,
                                                /*params=*/llvm::None);
     return hlfir::EntityWithAttributes{
         Fortran::lower::genPow(builder, loc, ty, lhs, rhs)};
   }
 };
 
 template <Fortran::common::TypeCategory TC, int KIND>
 struct BinaryOp<
     Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>> {
   using Op =
       Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs,
-                                         hlfir::Entity rhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs, hlfir::Entity rhs) {
     mlir::Type ty = Fortran::lower::getFIRType(builder.getContext(), TC, KIND,
                                                /*params=*/llvm::None);
     return hlfir::EntityWithAttributes{
         Fortran::lower::genPow(builder, loc, ty, lhs, rhs)};
   }
 };
 
 template <Fortran::common::TypeCategory TC, int KIND>
static hlfir::EntityWithAttributes gen(mlir::Location loc,
     llvm_unreachable("unhandled logical operation");
   }
 };
 
 template <int KIND>
 struct BinaryOp<Fortran::evaluate::ComplexConstructor<KIND>> {
   using Op = Fortran::evaluate::ComplexConstructor<KIND>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs,
-                                         hlfir::Entity rhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs, hlfir::Entity rhs) {
     mlir::Value res =
         fir::factory::Complex{builder, loc}.createComplex(KIND, lhs, rhs);
     return hlfir::EntityWithAttributes{res};
   }
 };
 
 template <int KIND>
 struct BinaryOp<Fortran::evaluate::SetLength<KIND>> {
   using Op = Fortran::evaluate::SetLength<KIND>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs,
-                                         hlfir::Entity rhs) {
+                                         fir::FirOpBuilder &, const Op &,
+                                         hlfir::Entity, hlfir::Entity) {
     TODO(loc, "SetLength lowering to HLFIR");
   }
 };
 
 //===--------------------------------------------------------------------===//
 // Unary Operation implementation
 //===--------------------------------------------------------------------===//
 
 template <typename T>
 struct UnaryOp {};
 
 template <int KIND>
 struct UnaryOp<Fortran::evaluate::Not<KIND>> {
   using Op = Fortran::evaluate::Not<KIND>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs) {
     mlir::Value one = builder.createBool(loc, true);
     mlir::Value val = builder.createConvert(loc, builder.getI1Type(), lhs);
     return hlfir::EntityWithAttributes{
         builder.create<mlir::arith::XOrIOp>(loc, val, one)};
   }
 };
 
 template <int KIND>
 struct UnaryOp<Fortran::evaluate::Negate<
     Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, KIND>>> {
   using Op = Fortran::evaluate::Negate<
       Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs) {
     // Like LLVM, integer negation is the binary op "0 - value"
     mlir::Type type = Fortran::lower::getFIRType(
         builder.getContext(), Fortran::common::TypeCategory::Integer, KIND,
         /*params=*/llvm::None);
     mlir::Value zero = builder.createIntegerConstant(loc, type, 0);
     return hlfir::EntityWithAttributes{
         builder.create<mlir::arith::SubIOp>(loc, zero, lhs)};
   }
 };
 
 template <int KIND>
 struct UnaryOp<Fortran::evaluate::Negate<
     Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, KIND>>> {
   using Op = Fortran::evaluate::Negate<
       Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs) {
     return hlfir::EntityWithAttributes{
         builder.create<mlir::arith::NegFOp>(loc, lhs)};
   }
 };
 
 template <int KIND>
 struct UnaryOp<Fortran::evaluate::Negate<
     Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, KIND>>> {
   using Op = Fortran::evaluate::Negate<
       Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs) {
     return hlfir::EntityWithAttributes{builder.create<fir::NegcOp>(loc, lhs)};
   }
 };
 
 template <int KIND>
 struct UnaryOp<Fortran::evaluate::ComplexComponent<KIND>> {
   using Op = Fortran::evaluate::ComplexComponent<KIND>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder,
                                          const Op &op, hlfir::Entity lhs) {
     mlir::Value res = fir::factory::Complex{builder, loc}.extractComplexPart(
         lhs, op.isImaginaryPart);
     return hlfir::EntityWithAttributes{res};
   }
 };
 
 template <typename T>
 struct UnaryOp<Fortran::evaluate::Parentheses<T>> {
   using Op = Fortran::evaluate::Parentheses<T>;
-  static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+  static hlfir::EntityWithAttributes
+  gen(mlir::Location loc, fir::FirOpBuilder &, const Op &, hlfir::Entity) {
     TODO(loc, "Parentheses lowering to HLFIR");
   }
 };
 
 template <Fortran::common::TypeCategory TC1, int KIND,
           Fortran::common::TypeCategory TC2>
 struct UnaryOp<
     Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>> {
   using Op =
       Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
-                                         fir::FirOpBuilder &builder,
-                                         const Op &op, hlfir::Entity lhs) {
+                                         fir::FirOpBuilder &builder, const Op &,
+                                         hlfir::Entity lhs) {
     if constexpr (TC1 == Fortran::common::TypeCategory::Character &&
                   TC2 == TC1) {
       TODO(loc, "character conversion in HLFIR");
-    } else {
-      mlir::Type type = Fortran::lower::getFIRType(builder.getContext(), TC1,
-                                                   KIND, /*params=*/llvm::None);
-      mlir::Value res = builder.convertWithSemantics(loc, type, lhs);
-      return hlfir::EntityWithAttributes{res};
-    }
-  }
+    }
 };
 
 /// Lower Expr to HLFIR.
 class HlfirBuilder {
 public:
   HlfirBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
                Fortran::lower::SymMap &symMap,
                Fortran::lower::StatementContext &stmtCtx)