diff --git a/flang/lib/decimal/big-radix-floating-point.h b/flang/lib/decimal/big-radix-floating-point.h
index 49e9efc6f0d2..688496456d36 100644
--- a/flang/lib/decimal/big-radix-floating-point.h
+++ b/flang/lib/decimal/big-radix-floating-point.h
@@ -62,7 +62,7 @@ private:
   // The base-2 logarithm of the least significant bit that can arise
   // in a subnormal IEEE floating-point number.
   static constexpr int minLog2AnyBit{
-      -static_cast<int>(Real::exponentBias) - Real::precision};
+      -int{Real::exponentBias} - Real::precision};
   static constexpr int maxDigits{3 - minLog2AnyBit / log10Radix};
 
 public:
diff --git a/flang/lib/decimal/binary-floating-point.h b/flang/lib/decimal/binary-floating-point.h
index 2048a760bec7..53421666f65d 100644
--- a/flang/lib/decimal/binary-floating-point.h
+++ b/flang/lib/decimal/binary-floating-point.h
@@ -55,8 +55,7 @@ template<int PRECISION> struct BinaryFloatingPointNumber {
   static constexpr int exponentBits{bits - 1 - significandBits};
   static constexpr int maxExponent{(1 << exponentBits) - 1};
   static constexpr int exponentBias{maxExponent / 2};
-  static constexpr RawType significandMask{
-      (static_cast<RawType>(1) << significandBits) - 1};
+  static constexpr RawType significandMask{(RawType{1} << significandBits) - 1};
 
   BinaryFloatingPointNumber() {}  // zero
   BinaryFloatingPointNumber(const BinaryFloatingPointNumber &that) = default;
@@ -83,13 +82,13 @@ template<int PRECISION> struct BinaryFloatingPointNumber {
   constexpr RawType Fraction() const {
     RawType sig{Significand()};
     if (implicitMSB && BiasedExponent() > 0) {
-      sig |= static_cast<RawType>(1) << significandBits;
+      sig |= RawType{1} << significandBits;
     }
     return sig;
   }
 
   constexpr bool IsZero() const {
-    return (raw & ((static_cast<RawType>(1) << (bits - 1)) - 1)) == 0;
+    return (raw & ((RawType{1} << (bits - 1)) - 1)) == 0;
   }
   constexpr bool IsNaN() const {
     return BiasedExponent() == maxExponent && Significand() != 0;
@@ -103,7 +102,7 @@ template<int PRECISION> struct BinaryFloatingPointNumber {
   }
   constexpr bool IsNegative() const { return (raw >> (bits - 1)) & 1; }
 
-  constexpr void Negate() { raw ^= static_cast<RawType>(1) << (bits - 1); }
+  constexpr void Negate() { raw ^= RawType{1} << (bits - 1); }
 
   RawType raw{0};
 };
diff --git a/flang/lib/decimal/decimal-to-binary.cc b/flang/lib/decimal/decimal-to-binary.cc
index a6f24fcbc025..9da979108059 100644
--- a/flang/lib/decimal/decimal-to-binary.cc
+++ b/flang/lib/decimal/decimal-to-binary.cc
@@ -136,7 +136,7 @@ template<int PREC> class IntermediateFloat {
 public:
   static constexpr int precision{PREC};
   using IntType = HostUnsignedIntType<precision>;
-  static constexpr IntType topBit{static_cast<IntType>(1) << (precision - 1)};
+  static constexpr IntType topBit{IntType{1} << (precision - 1)};
   static constexpr IntType mask{topBit + (topBit - 1)};
 
   IntermediateFloat() {}
@@ -179,8 +179,7 @@ public:
 private:
   static constexpr int guardBits{3};  // guard, round, sticky
   using GuardType = int;
-  static constexpr GuardType oneHalf{
-      static_cast<GuardType>(1) << (guardBits - 1)};
+  static constexpr GuardType oneHalf{GuardType{1} << (guardBits - 1)};
 
   IntType value_{0};
   GuardType guard_{0};
@@ -265,7 +264,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   if (digits_ == 0) {  // zero value
     if (isNegative_) {
       using Raw = typename Binary::RawType;
-      Raw negZero{static_cast<Raw>(1) << (Binary::bits - 1)};
+      Raw negZero{Raw{1} << (Binary::bits - 1)};
       return {Binary{negZero}};
     } else {
       return {Binary{}};
@@ -360,11 +359,9 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary(const char *&p) {
     using Binary = BinaryFloatingPointNumber<PREC>;
     using Raw = typename Binary::RawType;
     static constexpr Raw inf{
-        static_cast<Raw>(Binary::maxExponent) << Binary::significandBits};
-    static constexpr Raw nan{
-        inf | (static_cast<Raw>(1) << (Binary::significandBits - 2))};
-    static constexpr Raw negInf{
-        inf | (static_cast<Raw>(1) << (Binary::bits - 1))};
+        Raw{Binary::maxExponent} << Binary::significandBits};
+    static constexpr Raw nan{inf | (Raw{1} << (Binary::significandBits - 2))};
+    static constexpr Raw negInf{inf | (Raw{1} << (Binary::bits - 1))};
     if (toupper(p[0]) == 'N' && toupper(p[1]) == 'A' && toupper(p[2]) == 'N') {
       // NaN
       p += 3;
diff --git a/flang/lib/decimal/int-divide-workaround.h b/flang/lib/decimal/int-divide-workaround.h
index 8ccb459bda09..21d2cb65e2d2 100644
--- a/flang/lib/decimal/int-divide-workaround.h
+++ b/flang/lib/decimal/int-divide-workaround.h
@@ -33,48 +33,70 @@ template<typename UINT, UINT DENOM> inline constexpr UINT FastDivision(UINT n) {
 }
 
 #if USE_INT_DIVIDE_WORKAROUNDS
-template<> inline constexpr std::uint64_t FastDivision<std::uint64_t, 10000000000000000u>(std::uint64_t n) {
-  return (static_cast<__uint128_t>(0x39a5652fb1137857) * n) >> (64 + 51);
+template<>
+inline constexpr std::uint64_t FastDivision<std::uint64_t, 10000000000000000u>(
+    std::uint64_t n) {
+  cast<__uint128_t{0x39a5652fb1137857} * n) >> (64 + 51);
 }
 
-template<> inline constexpr std::uint64_t FastDivision<std::uint64_t, 100000000000000u>(std::uint64_t n) {
-  return (static_cast<__uint128_t>(0xb424dc35095cd81) * n) >> (64 + 42);
+template<>
+inline constexpr std::uint64_t FastDivision<std::uint64_t, 100000000000000u>(
+    std::uint64_t n) {
+  return (__uint128_t{0xb424dc35095cd81} * n) >> (64 + 42);
 }
 
-template<> inline constexpr std::uint32_t FastDivision<std::uint32_t, 1000000u>(std::uint32_t n) {
-  return (static_cast<std::uint64_t>(0x431bde83) * n) >> (32 + 18);
+template<>
+inline constexpr std::uint32_t FastDivision<std::uint32_t, 1000000u>(
+    std::uint32_t n) {
+  return (std::uint64_t{0x431bde83} * n) >> (32 + 18);
 }
 
-template<> inline constexpr std::uint32_t FastDivision<std::uint32_t, 10000u>(std::uint32_t n) {
-  return (static_cast<std::uint64_t>(0xd1b71759) * n) >> (32 + 13);
+template<>
+inline constexpr std::uint32_t FastDivision<std::uint32_t, 10000u>(
+    std::uint32_t n) {
+  return (std::uint64_t{0xd1b71759} * n) >> (32 + 13);
 }
 
-template<> inline constexpr std::uint64_t FastDivision<std::uint64_t, 10u>(std::uint64_t n) {
-  return (static_cast<__uint128_t>(0xcccccccccccccccd) * n) >> (64 + 3);
+template<>
+inline constexpr std::uint64_t FastDivision<std::uint64_t, 10u>(
+    std::uint64_t n) {
+  return (__uint128_t{0xcccccccccccccccd} * n) >> (64 + 3);
 }
 
-template<> inline constexpr std::uint32_t FastDivision<std::uint32_t, 10u>(std::uint32_t n) {
-  return (static_cast<std::uint64_t>(0xcccccccd) * n) >> (32 + 3);
+template<>
+inline constexpr std::uint32_t FastDivision<std::uint32_t, 10u>(
+    std::uint32_t n) {
+  return (std::uint64_t{0xcccccccd} * n) >> (32 + 3);
 }
 
-template<> inline constexpr std::uint64_t FastDivision<std::uint64_t, 5u>(std::uint64_t n) {
-  return (static_cast<__uint128_t>(0xcccccccccccccccd) * n) >> (64 + 2);
+template<>
+inline constexpr std::uint64_t FastDivision<std::uint64_t, 5u>(
+    std::uint64_t n) {
+  return (__uint128_t{0xcccccccccccccccd} * n) >> (64 + 2);
 }
 
-template<> inline constexpr std::uint32_t FastDivision<std::uint32_t, 5u>(std::uint32_t n) {
-  return (static_cast<std::uint64_t>(0xcccccccd) * n) >> (32 + 2);
+template<>
+inline constexpr std::uint32_t FastDivision<std::uint32_t, 5u>(
+    std::uint32_t n) {
+  return (std::uint64_t{0xcccccccd} * n) >> (32 + 2);
 }
 #endif
 
-static_assert(FastDivision<std::uint64_t, 10000000000000000u>(9999999999999999u) == 0);
-static_assert(FastDivision<std::uint64_t, 10000000000000000u>(10000000000000000u) == 1);
-static_assert(FastDivision<std::uint64_t, 100000000000000u>(99999999999999u) == 0);
-static_assert(FastDivision<std::uint64_t, 100000000000000u>(100000000000000u) == 1);
+static_assert(
+    FastDivision<std::uint64_t, 10000000000000000u>(9999999999999999u) == 0);
+static_assert(
+    FastDivision<std::uint64_t, 10000000000000000u>(10000000000000000u) == 1);
+static_assert(
+    FastDivision<std::uint64_t, 100000000000000u>(99999999999999u) == 0);
+static_assert(
+    FastDivision<std::uint64_t, 100000000000000u>(100000000000000u) == 1);
 static_assert(FastDivision<std::uint32_t, 1000000u>(999999u) == 0);
 static_assert(FastDivision<std::uint32_t, 1000000u>(1000000u) == 1);
-static_assert(FastDivision<std::uint64_t, 10>(18446744073709551615u) == 1844674407370955161u);
+static_assert(FastDivision<std::uint64_t, 10>(18446744073709551615u) ==
+    1844674407370955161u);
 static_assert(FastDivision<std::uint32_t, 10>(4294967295u) == 429496729u);
-static_assert(FastDivision<std::uint64_t, 5>(18446744073709551615u) == 3689348814741910323u);
+static_assert(FastDivision<std::uint64_t, 5>(18446744073709551615u) ==
+    3689348814741910323u);
 static_assert(FastDivision<std::uint32_t, 5>(4294967295u) == 858993459u);
 }
 #endif